haskell-src-exts 0.3.12 → 0.4.1
raw patch · 9 files changed
+6988/−7059 lines, 9 files
Files
- Language/Haskell/Exts.hs +11/−11
- Language/Haskell/Exts/Build.hs +141/−140
- Language/Haskell/Exts/Lexer.hs +6/−65
- Language/Haskell/Exts/ParseUtils.hs +368/−293
- Language/Haskell/Exts/Parser.ly +372/−398
- Language/Haskell/Exts/Pretty.hs +319/−362
- Language/Haskell/Exts/Syntax.hs +311/−325
- dist/build/Language/Haskell/Exts/Parser.hs +5458/−5460
- haskell-src-exts.cabal +2/−5
Language/Haskell/Exts.hs view
@@ -1,25 +1,25 @@ 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+ 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 -parseFile :: FilePath -> IO (ParseResult HsModule)+parseFile :: FilePath -> IO (ParseResult Module) parseFile fp = readFile fp >>= (return . parseFileContentsWithMode (ParseMode fp)) -parseFileContents :: String -> ParseResult HsModule+parseFileContents :: String -> ParseResult Module parseFileContents = parseFileContentsWithMode defaultParseMode -parseFileContentsWithMode :: ParseMode -> String -> ParseResult HsModule+parseFileContentsWithMode :: ParseMode -> String -> ParseResult Module parseFileContentsWithMode p rawStr = parseModuleWithMode p (unlines $ map f $ lines rawStr) where f ('#':_) = ""
Language/Haskell/Exts/Build.hs view
@@ -12,57 +12,58 @@ -- ----------------------------------------------------------------------------- +-- This module badly needs Haddock documentation. module Language.Haskell.Exts.Build ( -- * Syntax building functions- name, -- :: String -> HsName- sym, -- :: String -> HsName- var, -- :: HsName -> HsExp- op, -- :: HsName -> HsQOp- qvar, -- :: Module -> HsName -> HsExp- pvar, -- :: HsName -> HsPat- app, -- :: HsExp -> HsExp -> HsExp- infixApp, -- :: HsExp -> HsQOp -> HsExp -> HsExp- appFun, -- :: HsExp -> [HsExp] -> HsExp- pApp, -- :: HsName -> [HsPat] -> HsPat- tuple, -- :: [HsExp] -> HsExp- pTuple, -- :: [HsPat] -> HsPat- varTuple, -- :: [HsName] -> HsExp- pvarTuple, -- :: [HsName] -> HsPat- function, -- :: String -> HsExp- strE, -- :: String -> HsExp- charE, -- :: Char -> HsExp- intE, -- :: Integer -> HsExp- strP, -- :: String -> HsPat- charP, -- :: Char -> HsPat- intP, -- :: Integer -> HsPat- doE, -- :: [HsStmt] -> HsExp- lamE, -- :: SrcLoc -> [HsPat] -> HsExp -> HsExp- letE, -- :: [HsDecl] -> HsExp -> HsExp- caseE, -- :: HsExp -> [HsAlt] -> HsExp- alt, -- :: SrcLoc -> HsPat -> HsExp -> HsAlt- altGW, -- :: SrcLoc -> HsPat -> [HsStmt] -> HsExp -> HsBinds -> HsAlt- listE, -- :: [HsExp] -> HsExp- eList, -- :: HsExp- peList, -- :: HsPat- paren, -- :: HsExp -> HsExp- pParen, -- :: HsPat -> HsPat- qualStmt, -- :: HsExp -> HsStmt- genStmt, -- :: SrcLoc -> HsPat -> HsExp -> HsStmt- letStmt, -- :: [HsDecl] -> HsStmt- binds, -- :: [HsDecl] -> HsBinds- noBinds, -- :: HsBinds- wildcard, -- :: HsPat- genNames, -- :: String -> Int -> [HsName]+ 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 -> HsName -> [HsName] -> HsRhs -> HsBinds -> HsDecl- simpleFun, -- :: SrcLoc -> HsName -> HsName -> HsExp -> HsDecl- patBind, -- :: SrcLoc -> HsPat -> HsExp -> HsDecl- patBindWhere, -- :: SrcLoc -> HsPat -> HsExp -> [HsDecl] -> HsDecl- nameBind, -- :: SrcLoc -> HsName -> HsExp -> HsDecl- metaFunction, -- :: String -> [HsExp] -> HsExp- metaConPat -- :: String -> [HsPat] -> HsPat+ 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@@ -70,166 +71,166 @@ ----------------------------------------------------------------------------- -- Help functions for Abstract syntax -name :: String -> HsName-name = HsIdent+name :: String -> Name+name = Ident -sym :: String -> HsName-sym = HsSymbol+sym :: String -> Name+sym = Symbol -var :: HsName -> HsExp-var = HsVar . UnQual+var :: Name -> Exp+var = Var . UnQual -op :: HsName -> HsQOp-op = HsQVarOp . UnQual+op :: Name -> QOp+op = QVarOp . UnQual -qvar :: Module -> HsName -> HsExp-qvar m n = HsVar $ Qual m n+qvar :: ModuleName -> Name -> Exp+qvar m n = Var $ Qual m n -pvar :: HsName -> HsPat-pvar = HsPVar+pvar :: Name -> Pat+pvar = PVar -app :: HsExp -> HsExp -> HsExp-app = HsApp+app :: Exp -> Exp -> Exp+app = App -infixApp :: HsExp -> HsQOp -> HsExp -> HsExp-infixApp = HsInfixApp+infixApp :: Exp -> QOp -> Exp -> Exp+infixApp = InfixApp -appFun :: HsExp -> [HsExp] -> HsExp+appFun :: Exp -> [Exp] -> Exp appFun f [] = f appFun f (a:as) = appFun (app f a) as -pApp :: HsName -> [HsPat] -> HsPat-pApp n ps = HsPApp (UnQual n) ps+pApp :: Name -> [Pat] -> Pat+pApp n ps = PApp (UnQual n) ps -tuple :: [HsExp] -> HsExp-tuple = HsTuple+tuple :: [Exp] -> Exp+tuple = Tuple -pTuple :: [HsPat] -> HsPat-pTuple = HsPTuple+pTuple :: [Pat] -> Pat+pTuple = PTuple -varTuple :: [HsName] -> HsExp+varTuple :: [Name] -> Exp varTuple ns = tuple $ map var ns -pvarTuple :: [HsName] -> HsPat+pvarTuple :: [Name] -> Pat pvarTuple ns = pTuple $ map pvar ns -function :: String -> HsExp-function = var . HsIdent+function :: String -> Exp+function = var . Ident -strE :: String -> HsExp-strE = HsLit . HsString+strE :: String -> Exp+strE = Lit . String -charE :: Char -> HsExp-charE = HsLit . HsChar+charE :: Char -> Exp+charE = Lit . Char -intE :: Integer -> HsExp-intE = HsLit . HsInt+intE :: Integer -> Exp+intE = Lit . Int -strP :: String -> HsPat-strP = HsPLit . HsString+strP :: String -> Pat+strP = PLit . String -charP :: Char -> HsPat-charP = HsPLit . HsChar+charP :: Char -> Pat+charP = PLit . Char -intP :: Integer -> HsPat-intP = HsPLit . HsInt+intP :: Integer -> Pat+intP = PLit . Int -doE :: [HsStmt] -> HsExp-doE = HsDo+doE :: [Stmt] -> Exp+doE = Do -lamE :: SrcLoc -> [HsPat] -> HsExp -> HsExp-lamE = HsLambda+lamE :: SrcLoc -> [Pat] -> Exp -> Exp+lamE = Lambda -letE :: [HsDecl] -> HsExp -> HsExp-letE ds e = HsLet (binds ds) e+letE :: [Decl] -> Exp -> Exp+letE ds e = Let (binds ds) e -caseE :: HsExp -> [HsAlt] -> HsExp-caseE = HsCase+caseE :: Exp -> [Alt] -> Exp+caseE = Case -alt :: SrcLoc -> HsPat -> HsExp -> HsAlt-alt s p e = HsAlt s p (HsUnGuardedAlt e) noBinds+alt :: SrcLoc -> Pat -> Exp -> Alt+alt s p e = Alt s p (UnGuardedAlt e) noBinds -altGW :: SrcLoc -> HsPat -> [HsStmt] -> HsExp -> HsBinds -> HsAlt-altGW s p gs e w = HsAlt s p (gAlt s gs e) w+altGW :: SrcLoc -> Pat -> [Stmt] -> Exp -> Binds -> Alt+altGW s p gs e w = Alt s p (gAlt s gs e) w -unGAlt :: HsExp -> HsGuardedAlts-unGAlt = HsUnGuardedAlt+unGAlt :: Exp -> GuardedAlts+unGAlt = UnGuardedAlt -gAlts :: SrcLoc -> [([HsStmt],HsExp)] -> HsGuardedAlts-gAlts s as = HsGuardedAlts $ map (\(gs,e) -> HsGuardedAlt s gs e) as+gAlts :: SrcLoc -> [([Stmt],Exp)] -> GuardedAlts+gAlts s as = GuardedAlts $ map (\(gs,e) -> GuardedAlt s gs e) as -gAlt :: SrcLoc -> [HsStmt] -> HsExp -> HsGuardedAlts+gAlt :: SrcLoc -> [Stmt] -> Exp -> GuardedAlts gAlt s gs e = gAlts s [(gs,e)] -listE :: [HsExp] -> HsExp-listE = HsList+listE :: [Exp] -> Exp+listE = List -eList :: HsExp-eList = HsList []+eList :: Exp+eList = List [] -peList :: HsPat-peList = HsPList []+peList :: Pat+peList = PList [] -paren :: HsExp -> HsExp-paren = HsParen+paren :: Exp -> Exp+paren = Paren -pParen :: HsPat -> HsPat-pParen = HsPParen+pParen :: Pat -> Pat+pParen = PParen -qualStmt :: HsExp -> HsStmt-qualStmt = HsQualifier+qualStmt :: Exp -> Stmt+qualStmt = Qualifier -genStmt :: SrcLoc -> HsPat -> HsExp -> HsStmt-genStmt = HsGenerator+genStmt :: SrcLoc -> Pat -> Exp -> Stmt+genStmt = Generator -letStmt :: [HsDecl] -> HsStmt-letStmt ds = HsLetStmt $ binds ds+letStmt :: [Decl] -> Stmt+letStmt ds = LetStmt $ binds ds -binds :: [HsDecl] -> HsBinds-binds = HsBDecls+binds :: [Decl] -> Binds+binds = BDecls -noBinds :: HsBinds+noBinds :: Binds noBinds = binds [] -wildcard :: HsPat-wildcard = HsPWildCard+wildcard :: Pat+wildcard = PWildCard -genNames :: String -> Int -> [HsName]-genNames s k = [ HsIdent $ s ++ show i | i <- [1..k] ]+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 -> HsName -> [HsName] -> HsRhs -> HsBinds -> HsDecl-sfun s f pvs rhs bs = HsFunBind [HsMatch s f (map pvar pvs) rhs bs]+sfun :: SrcLoc -> Name -> [Name] -> Rhs -> Binds -> Decl+sfun s f pvs rhs bs = FunBind [Match s f (map pvar pvs) rhs bs] -- | A function with a single "match", a single argument, no guards -- and no where declarations-simpleFun :: SrcLoc -> HsName -> HsName -> HsExp -> HsDecl-simpleFun s f a e = let rhs = HsUnGuardedRhs e- in sfun s f [a] rhs noBinds+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 -> HsPat -> HsExp -> HsDecl-patBind s p e = let rhs = HsUnGuardedRhs e- in HsPatBind s p rhs noBinds+patBind :: SrcLoc -> Pat -> Exp -> Decl+patBind s p e = let rhs = UnGuardedRhs e+ in PatBind s p rhs noBinds -patBindWhere :: SrcLoc -> HsPat -> HsExp -> [HsDecl] -> HsDecl-patBindWhere s p e ds = let rhs = HsUnGuardedRhs e- in HsPatBind s p rhs (binds ds)+patBindWhere :: SrcLoc -> Pat -> Exp -> [Decl] -> Decl+patBindWhere s p e ds = let rhs = UnGuardedRhs e+ in PatBind s p rhs (binds ds) -nameBind :: SrcLoc -> HsName -> HsExp -> HsDecl+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 -> [HsExp] -> HsExp+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+ mf s (e:es) = app (mf s es) e -metaConPat :: String -> [HsPat] -> HsPat+metaConPat :: String -> [Pat] -> Pat metaConPat s ps = pApp (name s) ps
Language/Haskell/Exts/Lexer.hs view
@@ -88,16 +88,11 @@ | THVarQuote -- 'x (but without the x) | THTyQuote -- ''T (but without the T) --- | THReifyType--- | THReifyDecl--- | THReifyFixity- -- HaRP--- | RPSeqOpen -- (/--- | RPSeqClose -- /) | RPGuardOpen -- (| | RPGuardClose -- |) | RPCAt -- @:+ -- Hsx | XCodeTagOpen -- <% | XCodeTagClose -- %>@@ -105,7 +100,7 @@ | XStdTagClose -- > | XCloseTagOpen -- </ | XEmptyTagClose -- />- | XPcdata String+ | XPCDATA String | XRPatOpen -- <[ | XRPatClose -- ]> @@ -117,7 +112,6 @@ | KW_Data | KW_Default | KW_Deriving- | KW_DLet -- implictit parameter binding | KW_Do | KW_MDo | KW_Else@@ -138,7 +132,6 @@ | KW_Then | KW_Type | KW_Where- | KW_With -- implicit parameter binding | KW_Qualified -- FFI@@ -184,7 +177,6 @@ ( "data", KW_Data ), ( "default", KW_Default ), ( "deriving", KW_Deriving ),--- ( "dlet", KW_DLet ), -- implicit parameters (hugs), no longer supported in 0.3.11 ( "do", KW_Do ), ( "else", KW_Else ), ( "family", KW_Family ), -- indexed type families@@ -204,14 +196,7 @@ ( "then", KW_Then ), ( "type", KW_Type ), ( "where", KW_Where ),--- ( "with", KW_With ), -- implicit parameters in Hugs, no longer supported in 0.3.11 -{-- Template Haskell- ( "reifyDecl", THReifyDecl ),- ( "reifyType", THReifyType ),- ( "reifyFixity", THReifyFixity ),---}- -- FFI ( "foreign", KW_Foreign ) ]@@ -235,7 +220,6 @@ isIdent, isHSymbol :: Char -> Bool isIdent c = isAlpha c || isDigit c || c == '\'' || c == '_' ---isHSymbol c = elem c ":!#$%&*+./<=>?@\\^|-~" isHSymbol c = c `elem` ":!#%&*./?@\\-" || ((isSymbol c || isPunctuation c) && not (c `elem` "(),;[]`{}_\"'")) matchChar :: Char -> String -> Lex a ()@@ -256,7 +240,7 @@ 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 " "+ Just ChildCtxt | not bol && ws -> return $ XPCDATA " " _ -> do startToken if bol then lexBOL else lexToken @@ -369,21 +353,15 @@ '\n':_ -> do x <- lexNewline >> lexPCDATA case x of- XPcdata p -> return $ XPcdata $ '\n':p+ XPCDATA p -> return $ XPCDATA $ '\n':p EOF -> return EOF- '<':_ -> return $ XPcdata ""- -- '[':'/':_ -> return $ XPcdata ""- -- '[':s' -> do discard 1- -- pcd <- lexPCDATA- -- case pcd of- -- XPcdata pcd' -> return $ XPcdata $ '[':pcd'- -- EOF -> return EOF+ '<':_ -> 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'+ XPCDATA pcd' -> return $ XPCDATA $ pcd ++ pcd' EOF -> return EOF @@ -422,32 +400,9 @@ lexHarpToken = do s <- getInput case s of-{- '[':'/':_ -> do discard 2- pushExtContextL HarpCtxt- return RPOpen -} ']':'>':_ -> do discard 2 popExtContextL "lexHarpToken" return XRPatClose-{- '(':'/':_ -> do discard 2- return RPSeqOpen- '/':')':_ -> do discard 2- return RPSeqClose- '*':'!':_ -> do discard 2- return RPStarG- '*':_ -> do discard 1- return RPStar- '+':'!':_ -> do discard 2- return RPPlusG- '+':_ -> do discard 1- return RPPlus- '|':_ -> do discard 1- return RPEither- '?':'!':_ -> do discard 2- return RPOptG- '?':_ -> do discard 1- return RPOpt- '@':':':_ -> do discard 2- return RPCAt -} _ -> lexStdToken lexStdToken :: Lex a Token@@ -478,10 +433,6 @@ -- end implicit parameters -- harp--- '(':'/':_ -> do discard 2--- return RPSeqOpen--- '/':')':_ -> do discard 2--- return RPSeqClose '(':'|':c:_ | isHSymbol c -> discard 1 >> return LeftParen '(':'|':_ -> do discard 2 return RPGuardOpen@@ -691,16 +642,6 @@ where matchQuote = matchChar '\'' "Improperly terminated character constant" --{--lexChar :: Lex a Char-lexChar = do- r <- getInput- case r of- '\\':_ -> lexEscape- c:_ -> discard 1 >> return c- [] -> fail "Incomplete character constant"--} lexString :: Lex a Token lexString = loop ""
Language/Haskell/Exts/ParseUtils.hs view
@@ -16,59 +16,65 @@ ----------------------------------------------------------------------------- module Language.Haskell.Exts.ParseUtils (- splitTyConApp -- HsType -> P (HsName,[HsType])- , mkRecConstrOrUpdate -- HsExp -> [HsFieldUpdate] -> P HsExp- , checkPrec -- Integer -> P Int- , checkContext -- HsType -> P HsContext- , checkAssertion -- HsType -> P HsAsst- , checkDataHeader -- HsType -> P (HsContext,HsName,[HsName])- , checkClassHeader -- HsType -> P (HsContext,HsName,[HsName])- , checkInstHeader -- HsType -> P (HsContext,HsQName,[HsType])- , checkPattern -- HsExp -> P HsPat- , checkExpr -- HsExp -> P HsExp- , checkStmt -- HsStmt -> P HsStmt- , checkValDef -- SrcLoc -> HsExp -> HsRhs -> [HsDecl] -> P HsDecl- , checkClassBody -- [HsClassDecl] -> P [HsClassDecl]- , checkInstBody -- [HsInstDecl] -> P [HsInstDecl]- , checkUnQual -- HsQName -> P HsName- , checkRevDecls -- [HsDecl] -> P [HsDecl]- , checkRevClsDecls -- [HsClassDecl] -> P [HsClassDecl]- , checkRevInstDecls -- [HsInstDecl] -> P [HsInstDecl]- , checkDataOrNew -- DataOrNew -> [HsDecl] -> P ()- , checkSimpleType -- HsType -> P ()- , getGConName -- HsExp -> P HsQName- , mkHsTyForall -- Maybe [HsName] -> HsContext -> HsType -> HsType + 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+-- , checkStmt -- Stmt -> P Stmt+ , 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 ()+ , getGConName -- S.Exp -> P QName+ , mkTyForall -- Maybe [Name] -> Context -> Type -> Type -- HaRP- , checkRPattern -- HsExp -> P HsRPat+ , checkRPattern -- PExp -> P RPat -- Hsx- , checkEqNames -- HsXName -> HsXName -> P HsXName- , mkPageModule -- HsExp -> P HsModule- , mkPage -- HsModule -> SrcLoc -> HsExp -> P HsModule- , mkDVar -- [String] -> String- , mkDVarExpr -- [String] -> HsExp+ , checkEqNames -- XName -> XName -> P XName+ , mkPageModule -- S.Exp -> P Module+ , mkPage -- Module -> SrcLoc -> S.Exp -> P Module+ , mkDVar -- [String] -> String+ , mkDVarExpr -- [String] -> ParseExp+ + -- Parsed expressions+ , PExp(..), PFieldUpdate(..), ParseXAttr(..)+ , p_unit_con -- PExp+ , p_tuple_con -- Int -> PExp ) where -import Language.Haskell.Exts.Syntax+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 :: HsType -> P (HsName,[HsType])+splitTyConApp :: Type -> P (Name,[Type]) splitTyConApp t0 = split t0 [] where- split :: HsType -> [HsType] -> P (HsName,[HsType])- split (HsTyApp t u) ts = split t (u:ts)- split (HsTyCon (UnQual t)) ts = return (t,ts)- split (HsTyInfix a op b) ts = split (HsTyCon op) (a:b:ts)+ split :: 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 :: HsType -> P HsContext-checkContext (HsTyTuple Boxed ts) =+checkContext :: Type -> P Context+checkContext (TyTuple Boxed ts) = mapM checkAssertion ts checkContext t = do c <- checkAssertion t@@ -77,40 +83,40 @@ -- Changed for multi-parameter type classes. -- Further changed for implicit parameters. -checkAssertion :: HsType -> P HsAsst-checkAssertion (HsTyPred p@(HsIParam _ _)) = return p-checkAssertion (HsTyPred p@(HsEqualP _ _)) = return p+checkAssertion :: Type -> P Asst+checkAssertion (TyPred p@(IParam _ _)) = return p+checkAssertion (TyPred p@(EqualP _ _)) = return p checkAssertion t = checkAssertion' [] t- where checkAssertion' ts (HsTyCon c) = return $ HsClassA c ts- checkAssertion' ts (HsTyApp a t) = checkAssertion' (t:ts) a- checkAssertion' ts (HsTyInfix a op b) = checkAssertion' (a:b:ts) (HsTyCon op)+ 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 :: HsType -> P (HsContext,HsName,[HsName])-checkDataHeader (HsTyForall Nothing cs t) = do+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 :: HsType -> P (HsContext,HsName,[HsName])-checkClassHeader (HsTyForall Nothing cs t) = do+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 -> HsType -> [HsName] -> P (HsName,[HsName])-checkSimple kw (HsTyApp l (HsTyVar a)) xs = checkSimple kw l (a:xs)-checkSimple _ (HsTyInfix (HsTyVar a) (UnQual t) (HsTyVar b)) xs = return (t,a:b:xs)-checkSimple _kw (HsTyCon (UnQual t)) xs = return (t,xs)+checkSimple :: String -> Type -> [Name] -> P (Name,[Name])+checkSimple kw (TyApp l (TyVar a)) xs = checkSimple kw l (a:xs)+checkSimple _ (TyInfix (TyVar a) (UnQual t) (TyVar b)) xs = return (t,a:b:xs)+checkSimple _kw (TyCon (UnQual t)) xs = return (t,xs) checkSimple kw _ _ = fail ("Illegal " ++ kw ++ " declaration") -checkInstHeader :: HsType -> P (HsContext,HsQName,[HsType])-checkInstHeader (HsTyForall Nothing cs t) = do+checkInstHeader :: Type -> P (Context,QName,[Type])+checkInstHeader (TyForall Nothing cs t) = do (c,ts) <- checkInsts t [] return (cs,c,ts) checkInstHeader t = do@@ -118,78 +124,71 @@ return ([],c,ts) -checkInsts :: HsType -> [HsType] -> P ((HsQName,[HsType]))-checkInsts (HsTyApp l t) ts = checkInsts l (t:ts)-checkInsts (HsTyCon c) ts = return (c,ts)+checkInsts :: 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" -{--checkInst :: HsType -> P ()-checkInst (HsTyApp l _) = checkInst l-checkInst (HsTyVar _) = fail "Illegal instance declaration"-checkInst _ = return ()--}- ----------------------------------------------------------------------------- -- Checking Patterns. -- We parse patterns as expressions and check for valid patterns below, -- converting the expression into a pattern at the same time. -checkPattern :: HsExp -> P HsPat+checkPattern :: PExp -> P Pat checkPattern e = checkPat e [] -checkPat :: HsExp -> [HsPat] -> P HsPat-checkPat (HsCon c) args = return (HsPApp c args)-checkPat (HsApp f x) args = do+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- HsVar (UnQual x) -> return (HsPVar x)- HsLit l -> return (HsPLit l)- HsInfixApp l op r -> do+ Var (UnQual x) -> return (PVar x)+ Lit l -> return (PLit l)+ InfixApp l op r -> do l <- checkPat l [] r <- checkPat r [] case op of- HsQConOp c -> return (HsPInfixApp l c r)+ QConOp c -> return (PInfixApp l c r) _ -> patFail ""- HsTuple es -> do+ Tuple es -> do ps <- mapM (\e -> checkPat e []) es- return (HsPTuple ps)- HsList es -> do+ return (PTuple ps)+ List es -> do ps <- mapM checkRPattern es return $ if all isStdPat ps- then HsPList $ map stripRP ps- else HsPRPat $ map fixRPOpPrec ps- where isStdPat :: HsRPat -> Bool- isStdPat (HsRPPat _) = True- isStdPat (HsRPAs _ p) = isStdPat p+ 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 :: HsRPat -> HsPat- stripRP (HsRPPat p) = p- stripRP (HsRPAs n p) = HsPAsPat n (stripRP p)+ 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" - HsParen e -> do+ Paren e -> do p <- checkPat e []- return (HsPParen p)- HsAsPat n e -> do+ return (PParen p)+ AsPat n e -> do p <- checkPat e []- return (HsPAsPat n p)- HsWildCard -> return HsPWildCard- HsIrrPat e -> do+ return (PAsPat n p)+ WildCard -> return PWildCard+ IrrPat e -> do p <- checkPat e []- return (HsPIrrPat p)- HsRecConstr c fs -> do+ return (PIrrPat p)+ RecConstr c fs -> do fs <- mapM checkPatField fs- return (HsPRec c fs)- HsNegApp (HsLit l) -> return (HsPNeg (HsPLit l))- HsExpTypeSig s e t -> do+ return (PRec c fs)+ NegApp (Lit l) -> return (PNeg (PLit l))+ ExpTypeSig s e t -> do p <- checkPat e []- return (HsPatTypeSig s p t)+ return (PatTypeSig s p t) -- Hsx- HsXTag s n attrs mattr cs -> do+ XTag s n attrs mattr cs -> do pattrs <- mapM checkPAttr attrs pcs <- mapM (\c -> checkPat c []) cs mpattr <- maybe (return Nothing) @@ -197,290 +196,287 @@ return $ Just p) mattr let cps = mkChildrenPat pcs- return $ HsPXTag s n pattrs mpattr cps- HsXETag s n attrs mattr -> do+ 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 $ HsPXETag s n pattrs mpattr- HsXPcdata pcdata -> return $ HsPXPcdata pcdata- HsXExpTag e -> do+ return $ PXETag s n pattrs mpattr+ XPcdata pcdata -> return $ PXPcdata pcdata+ XExpTag e -> do p <- checkPat e []- return $ HsPXPatTag p- HsXRPats es -> do+ return $ PXPatTag p+ XRPats es -> do rps <- mapM checkRPattern es- return (HsPXRPats $ map fixRPOpPrec rps)+ return (PXRPats $ map fixRPOpPrec rps) e -> patFail $ show e checkPat e _ = patFail $ show e -checkPatField :: HsFieldUpdate -> P HsPatField-checkPatField (HsFieldUpdate n e) = do+checkPatField :: PFieldUpdate -> P PatField+checkPatField (FieldUpdate n e) = do p <- checkPat e []- return (HsPFieldPat n p)+ return (PFieldPat n p) -checkPAttr :: HsXAttr -> P HsPXAttr-checkPAttr (HsXAttr n v) = do p <- checkPat v []- return $ HsPXAttr n p+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 :: HsExp -> P HsRPat+checkRPattern :: PExp -> P RPat checkRPattern e = case e of- HsSeqRP es -> do + SeqRP es -> do rps <- mapM checkRPattern es- return $ HsRPSeq rps- HsPostOp e op -> do+ return $ RPSeq rps+ PostOp e op -> do rpop <- checkRPatOp op rp <- checkRPattern e- return $ HsRPOp rp rpop- HsGuardRP e gs -> do+ return $ RPOp rp rpop+ GuardRP e gs -> do rp <- checkPattern e- return $ HsRPGuard rp gs- HsEitherRP e1 e2 -> do+ return $ RPGuard rp gs+ EitherRP e1 e2 -> do rp1 <- checkRPattern e1 rp2 <- checkRPattern e2- return $ HsRPEither rp1 rp2- HsCAsRP n e -> do+ return $ RPEither rp1 rp2+ CAsRP n e -> do rp <- checkRPattern e- return $ HsRPCAs n rp- HsAsPat n e -> do+ return $ RPCAs n rp+ AsPat n e -> do rp <- checkRPattern e- return $ HsRPAs n rp- HsParen e -> do+ return $ RPAs n rp+ Paren e -> do rp <- checkRPattern e- return $ HsRPParen rp+ return $ RPParen rp _ -> do p <- checkPattern e- return $ HsRPPat p+ return $ RPPat p -checkRPatOp :: HsQOp -> P HsRPatOp-checkRPatOp o@(HsQVarOp (UnQual (HsSymbol sym))) =+checkRPatOp :: QOp -> P RPatOp+checkRPatOp o@(QVarOp (UnQual (Symbol sym))) = case sym of- "*" -> return HsRPStar- "*!" -> return HsRPStarG- "+" -> return HsRPPlus- "+!" -> return HsRPPlusG- "?" -> return HsRPOpt- "?!" -> return HsRPOptG+ "*" -> 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 :: HsRPat -> HsRPat+fixRPOpPrec :: RPat -> RPat fixRPOpPrec rp = case rp of- HsRPOp rp rpop -> fPrecOp rp (flip HsRPOp rpop)- HsRPEither rp1 rp2 -> HsRPEither (fixRPOpPrec rp1) (fixRPOpPrec rp2)- HsRPSeq rps -> HsRPSeq $ map fixRPOpPrec rps- HsRPCAs n rp -> HsRPCAs n $ fixRPOpPrec rp- HsRPAs n rp -> HsRPAs n $ fixRPOpPrec rp- HsRPParen rp -> HsRPParen $ fixRPOpPrec rp+ 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 :: HsRPat -> (HsRPat -> HsRPat) -> HsRPat- fPrecOp (HsRPOp rp rpop) f = fPrecOp rp (f . flip HsRPOp rpop)- fPrecOp (HsRPCAs n rp) f = fPrecAs rp f (HsRPCAs n)- fPrecOp (HsRPAs n rp) f = fPrecAs rp f (HsRPAs n)+ 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 :: HsRPat -> (HsRPat -> HsRPat) -> (HsRPat -> HsRPat) -> HsRPat- fPrecAs (HsRPCAs n rp) f g = fPrecAs rp f (g . HsRPCAs n)- fPrecAs (HsRPAs n rp) f g = fPrecAs rp f (g . HsRPAs n)+ 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 :: [HsPat] -> [HsPat]+mkChildrenPat :: [Pat] -> [Pat] mkChildrenPat ps = mkCPAux ps []- where mkCPAux :: [HsPat] -> [HsPat] -> [HsPat]+ where mkCPAux :: [Pat] -> [Pat] -> [Pat] mkCPAux [] qs = reverse qs mkCPAux (p:ps) qs = case p of- (HsPRPat rps) -> [mkCRP ps (reverse rps ++ map HsRPPat qs)]+ (PRPat rps) -> [mkCRP ps (reverse rps ++ map RPPat qs)] _ -> mkCPAux ps (p:qs) - mkCRP :: [HsPat] -> [HsRPat] -> HsPat- mkCRP [] rps = HsPXRPats $ reverse rps+ mkCRP :: [Pat] -> [RPat] -> Pat+ mkCRP [] rps = PXRPats $ reverse rps mkCRP (p:ps) rps = case p of- (HsPXRPats rqs) -> mkCRP ps (reverse rqs ++ rps)- _ -> mkCRP ps (HsRPPat p : rps)+ (PXRPats rqs) -> mkCRP ps (reverse rqs ++ rps)+ _ -> mkCRP ps (RPPat p : rps) ----------------------------------------------------------------------------- -- Check Expression Syntax -checkExpr :: HsExp -> P HsExp+checkExpr :: PExp -> P S.Exp checkExpr e = case e of- HsVar _ -> return e- HsIPVar _ -> return e- HsCon _ -> return e- HsLit _ -> return e- HsInfixApp e1 op e2 -> check2Exprs e1 e2 (flip HsInfixApp op)- HsApp e1 e2 -> check2Exprs e1 e2 HsApp- HsNegApp e -> check1Expr e HsNegApp- HsLambda loc ps e -> check1Expr e (HsLambda loc ps)- HsLet bs e -> check1Expr e (HsLet bs)--- HsDLet bs e -> check1Expr e (HsDLet bs)--- HsWith e bs -> check1Expr e (flip HsWith bs)- HsIf e1 e2 e3 -> check3Exprs e1 e2 e3 HsIf- HsCase e alts -> do- alts <- mapM checkAlt alts+ 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+-- alts <- mapM checkAlt alts e <- checkExpr e- return (HsCase e alts)- HsDo stmts -> do- stmts <- mapM checkStmt stmts- return (HsDo stmts)- HsMDo stmts -> do- stmts <- mapM checkStmt stmts- return (HsMDo stmts)- HsTuple es -> checkManyExprs es HsTuple- HsList es -> checkManyExprs es HsList+ return (S.Case e alts)+ Do stmts -> do+-- stmts <- mapM checkStmt stmts+ return (S.Do stmts)+ MDo stmts -> do+-- stmts <- mapM checkStmt 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.- HsParen e -> case e of- HsPostOp e1 op -> check1Expr e1 (flip HsLeftSection op)- _ -> check1Expr e HsParen- --HsLeftSection e op -> check1Expr e (flip HsLeftSection op)- HsRightSection op e -> check1Expr e (HsRightSection op)- HsRecConstr c fields -> do+ 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 (HsRecConstr c fields)- HsRecUpdate e fields -> do+ return (S.RecConstr c fields)+ RecUpdate e fields -> do fields <- mapM checkField fields e <- checkExpr e- return (HsRecUpdate e fields)- HsEnumFrom e -> check1Expr e HsEnumFrom- HsEnumFromTo e1 e2 -> check2Exprs e1 e2 HsEnumFromTo- HsEnumFromThen e1 e2 -> check2Exprs e1 e2 HsEnumFromThen- HsEnumFromThenTo e1 e2 e3 -> check3Exprs e1 e2 e3 HsEnumFromThenTo- HsListComp e stmts -> do+ 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 --stmts <- mapM checkStmt stmts e <- checkExpr e- return (HsListComp e stmts)- HsExpTypeSig loc e ty -> do+ return (S.ListComp e stmts)+ ExpTypeSig loc e ty -> do e <- checkExpr e- return (HsExpTypeSig loc e ty)+ return (S.ExpTypeSig loc e ty) --Template Haskell--- HsReifyExp _ -> return e- HsBracketExp _ -> return e- HsSpliceExp _ -> return e- HsTypQuote _ -> return e- HsVarQuote _ -> return e+ 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- HsXTag s n attrs mattr cs -> do attrs <- mapM checkAttr attrs- cs <- mapM checkExpr cs- mattr <- maybe (return Nothing) + 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 $ HsXTag s n attrs mattr cs- HsXETag s n attrs mattr -> do attrs <- mapM checkAttr attrs- mattr <- maybe (return Nothing) + 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 $ HsXETag s n attrs mattr - HsXPcdata _ -> return e- HsXExpTag e -> do e <- checkExpr e- return $ HsXExpTag e+ return $ S.XETag s n attrs mattr + XPcdata p -> return $ S.XPcdata p+ XExpTag e -> do e <- checkExpr e+ return $ S.XExpTag e _ -> fail $ "Parse error in expression: " ++ show e -checkAttr :: HsXAttr -> P HsXAttr-checkAttr (HsXAttr n v) = do v <- checkExpr v- return $ HsXAttr n v+checkAttr :: ParseXAttr -> P S.XAttr+checkAttr (XAttr n v) = do v <- checkExpr v+ return $ S.XAttr n v -- type signature for polymorphic recursion!!-check1Expr :: HsExp -> (HsExp -> a) -> P a+check1Expr :: PExp -> (S.Exp -> a) -> P a check1Expr e1 f = do e1 <- checkExpr e1 return (f e1) -check2Exprs :: HsExp -> HsExp -> (HsExp -> HsExp -> a) -> P a+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 :: HsExp -> HsExp -> HsExp -> (HsExp -> HsExp -> HsExp -> a) -> P a+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 :: [HsExp] -> ([HsExp] -> a) -> P a+checkManyExprs :: [PExp] -> ([S.Exp] -> a) -> P a checkManyExprs es f = do es <- mapM checkExpr es return (f es) -checkAlt :: HsAlt -> P HsAlt-checkAlt (HsAlt loc p galts bs) = do+{-+checkAlt :: Alt -> P Alt+checkAlt (Alt loc p galts bs) = do galts <- checkGAlts galts- return (HsAlt loc p galts bs)+ return (Alt loc p galts bs) -checkGAlts :: HsGuardedAlts -> P HsGuardedAlts-checkGAlts (HsUnGuardedAlt e) = check1Expr e HsUnGuardedAlt-checkGAlts (HsGuardedAlts galts) = do+checkGAlts :: GuardedAlts -> P GuardedAlts+checkGAlts (UnGuardedAlt e) = check1Expr e UnGuardedAlt+checkGAlts (GuardedAlts galts) = do galts <- mapM checkGAlt galts- return (HsGuardedAlts galts)--checkGAlt :: HsGuardedAlt -> P HsGuardedAlt-checkGAlt (HsGuardedAlt loc g e) = check1Expr e (HsGuardedAlt loc g)+ return (GuardedAlts galts) -checkStmt :: HsStmt -> P HsStmt-checkStmt (HsGenerator loc p e) = check1Expr e (HsGenerator loc p)-checkStmt (HsQualifier e) = check1Expr e HsQualifier-checkStmt s@(HsLetStmt _) = return s+checkGAlt :: GuardedAlt -> P GuardedAlt+checkGAlt (GuardedAlt loc g e) = check1Expr e (GuardedAlt loc g) -checkField :: HsFieldUpdate -> P HsFieldUpdate-checkField (HsFieldUpdate n e) = check1Expr e (HsFieldUpdate n)+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) -getGConName :: HsExp -> P HsQName-getGConName (HsCon n) = return n-getGConName (HsList []) = return list_cons_name+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 -> HsExp -> HsRhs -> HsBinds -> P HsDecl+checkValDef :: SrcLoc -> PExp -> Rhs -> Binds -> P Decl checkValDef srcloc lhs rhs whereBinds = case isFunLhs lhs [] of Just (f,es) -> do ps <- mapM checkPattern es- return (HsFunBind [HsMatch srcloc f ps rhs whereBinds])+ return (FunBind [Match srcloc f ps rhs whereBinds]) Nothing -> do lhs <- checkPattern lhs- return (HsPatBind srcloc lhs rhs whereBinds)+ return (PatBind srcloc lhs rhs whereBinds) --- A variable binding is parsed as an HsPatBind.+-- A variable binding is parsed as an PatBind. -isFunLhs :: HsExp -> [HsExp] -> Maybe (HsName, [HsExp])-isFunLhs (HsInfixApp l (HsQVarOp (UnQual op)) r) es = Just (op, l:r:es)-isFunLhs (HsApp (HsVar (UnQual f)) e) es = Just (f, e:es)-isFunLhs (HsApp (HsParen f) e) es = isFunLhs f (e:es)-isFunLhs (HsApp f e) es = isFunLhs f (e:es)+isFunLhs :: 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 ----------------------------------------------------------------------------- -- In a class or instance body, a pattern binding must be of a variable. -checkClassBody :: [HsClassDecl] -> P [HsClassDecl]+checkClassBody :: [ClassDecl] -> P [ClassDecl] checkClassBody decls = do mapM_ checkClassMethodDef decls return decls- where checkClassMethodDef (HsClsDecl decl) = checkMethodDef decl+ where checkClassMethodDef (ClsDecl decl) = checkMethodDef decl checkClassMethodDef _ = return () -checkInstBody :: [HsInstDecl] -> P [HsInstDecl]+checkInstBody :: [InstDecl] -> P [InstDecl] checkInstBody decls = do mapM_ checkInstMethodDef decls return decls- where checkInstMethodDef (HsInsDecl decl) = checkMethodDef decl+ where checkInstMethodDef (InsDecl decl) = checkMethodDef decl checkInstMethodDef _ = return () -checkMethodDef :: HsDecl -> P ()-checkMethodDef (HsPatBind _ (HsPVar _) _ _) = return ()-checkMethodDef (HsPatBind loc _ _ _) =+checkMethodDef :: Decl -> P ()+checkMethodDef (PatBind _ (PVar _) _ _) = return ()+checkMethodDef (PatBind loc _ _ _) = fail "illegal method definition" `atSrcLoc` loc checkMethodDef _ = return () @@ -488,7 +484,7 @@ -- Check that an identifier or symbol is unqualified. -- For occasions when doing this in the grammar would cause conflicts. -checkUnQual :: HsQName -> P HsName+checkUnQual :: QName -> P Name checkUnQual (Qual _ _) = fail "Illegal qualified name" checkUnQual (UnQual n) = return n checkUnQual (Special _) = fail "Illegal special name"@@ -498,11 +494,11 @@ -- Could use Eq directly, but I am not sure whether <dom:name>...</name> -- would be valid, in that case Eq won't work. TODO -checkEqNames :: HsXName -> HsXName -> P HsXName-checkEqNames n@(HsXName n1) (HsXName n2) +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@(HsXDomName d1 n1) (HsXDomName d2 n2)+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"@@ -515,64 +511,64 @@ checkPrec i | 0 <= i && i <= 9 = return (fromInteger i) checkPrec i | otherwise = fail ("Illegal precedence " ++ show i) -mkRecConstrOrUpdate :: HsExp -> [HsFieldUpdate] -> P HsExp-mkRecConstrOrUpdate (HsCon c) fs = return (HsRecConstr c fs)-mkRecConstrOrUpdate e fs@(_:_) = return (HsRecUpdate e fs)-mkRecConstrOrUpdate _ _ = fail "Empty record update"+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 HsFunBinds of the+-- Reverse a list of declarations, merging adjacent FunBinds of the -- same name and checking that their arities match. -checkRevDecls :: [HsDecl] -> P [HsDecl]+checkRevDecls :: [Decl] -> P [Decl] checkRevDecls = mergeFunBinds [] where mergeFunBinds revDs [] = return revDs- mergeFunBinds revDs (HsFunBind ms1@(HsMatch _ name ps _ _:_):ds1) =+ mergeFunBinds revDs (FunBind ms1@(Match _ name ps _ _:_):ds1) = mergeMatches ms1 ds1 where arity = length ps- mergeMatches ms' (HsFunBind ms@(HsMatch loc name' ps' _ _:_):ds)+ 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 (HsFunBind ms':revDs) ds+ mergeMatches ms' ds = mergeFunBinds (FunBind ms':revDs) ds mergeFunBinds revDs (d:ds) = mergeFunBinds (d:revDs) ds -checkRevClsDecls :: [HsClassDecl] -> P [HsClassDecl]+checkRevClsDecls :: [ClassDecl] -> P [ClassDecl] checkRevClsDecls = mergeClsFunBinds [] where mergeClsFunBinds revDs [] = return revDs- mergeClsFunBinds revDs (HsClsDecl (HsFunBind ms1@(HsMatch _ name ps _ _:_)):ds1) =+ mergeClsFunBinds revDs (ClsDecl (FunBind ms1@(Match _ name ps _ _:_)):ds1) = mergeMatches ms1 ds1 where arity = length ps- mergeMatches ms' (HsClsDecl (HsFunBind ms@(HsMatch loc name' ps' _ _:_)):ds)+ 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 (HsClsDecl (HsFunBind ms'):revDs) ds+ mergeMatches ms' ds = mergeClsFunBinds (ClsDecl (FunBind ms'):revDs) ds mergeClsFunBinds revDs (d:ds) = mergeClsFunBinds (d:revDs) ds -checkRevInstDecls :: [HsInstDecl] -> P [HsInstDecl]+checkRevInstDecls :: [InstDecl] -> P [InstDecl] checkRevInstDecls = mergeInstFunBinds [] where mergeInstFunBinds revDs [] = return revDs- mergeInstFunBinds revDs (HsInsDecl (HsFunBind ms1@(HsMatch _ name ps _ _:_)):ds1) =+ mergeInstFunBinds revDs (InsDecl (FunBind ms1@(Match _ name ps _ _:_)):ds1) = mergeMatches ms1 ds1 where arity = length ps- mergeMatches ms' (HsInsDecl (HsFunBind ms@(HsMatch loc name' ps' _ _:_)):ds)+ 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 (HsInsDecl (HsFunBind ms'):revDs) ds+ mergeMatches ms' ds = mergeInstFunBinds (InsDecl (FunBind ms'):revDs) ds mergeInstFunBinds revDs (d:ds) = mergeInstFunBinds (d:revDs) ds ----------------------------------------------------------------@@ -584,33 +580,33 @@ checkDataOrNew DataType _ = return () checkDataOrNew _ _ = fail "newtype declaration must have exactly one constructor." -checkSimpleType :: HsType -> P (HsName, [HsName])+checkSimpleType :: Type -> P (Name, [Name]) checkSimpleType t = checkSimple "test" t [] --------------------------------------- -- Converting a complete page -pageFun :: SrcLoc -> HsExp -> HsDecl-pageFun loc e = HsPatBind loc namePat rhs (HsBDecls [])- where namePat = HsPVar $ HsIdent "page"- rhs = HsUnGuardedRhs e+pageFun :: SrcLoc -> S.Exp -> Decl+pageFun loc e = PatBind loc namePat rhs (BDecls [])+ where namePat = PVar $ Ident "page"+ rhs = UnGuardedRhs e -mkPage :: HsModule -> SrcLoc -> HsExp -> P HsModule-mkPage (HsModule src md exps imps decls) loc xml = do+mkPage :: Module -> SrcLoc -> S.Exp -> P Module+mkPage (Module src md exps imps decls) loc xml = do let page = pageFun loc xml- return $ HsModule src md exps imps (decls ++ [page])+ return $ Module src md exps imps (decls ++ [page]) -mkPageModule :: HsExp -> P HsModule+mkPageModule :: S.Exp -> P Module mkPageModule xml = do do loc <- case xml of - HsXTag l _ _ _ _ -> return l- HsXETag l _ _ _ -> return l+ 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 $ (HsModule + return $ (Module loc- (Module mod)- (Just [HsEVar $ UnQual $ HsIdent "page"])+ (ModuleName mod)+ (Just [EVar $ UnQual $ Ident "page"]) [] [pageFun loc xml]) @@ -620,23 +616,102 @@ mkDVar :: [String] -> String mkDVar = concat . intersperse "-" -mkDVarExpr :: [String] -> HsExp-mkDVarExpr = foldl1 (\x y -> infixApp x (op $ sym "-") y) . map (var . name)+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 -mkHsTyForall :: Maybe [HsTyVarBind] -> HsContext -> HsType -> HsType-mkHsTyForall mtvs [] ty = mk_forall_ty mtvs ty-mkHsTyForall mtvs ctxt ty = HsTyForall mtvs ctxt ty+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 (HsTyForall mtvs2 ctxt ty) = mkHsTyForall (mtvs1 `plus` mtvs2) ctxt ty-mk_forall_ty mtvs1 ty = HsTyForall mtvs1 [] ty+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+ | 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++-- 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]+ deriving (Eq,Show)++data PFieldUpdate = + FieldUpdate QName PExp+ 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)
Language/Haskell/Exts/Parser.ly view
@@ -18,7 +18,8 @@ > parseModule, parseModuleWithMode, > ParseMode(..), defaultParseMode, ParseResult(..)) where > -> import Language.Haskell.Exts.Syntax+> 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@@ -120,8 +121,6 @@ Harp - '(/' { RPSeqOpen }- '/)' { RPSeqClose } > '(|' { RPGuardOpen } > '|)' { RPGuardClose } > '@:' { RPCAt }@@ -138,13 +137,9 @@ > VARQUOTE { THVarQuote } -- 'x > TYPQUOTE { THTyQuote } -- ''T - 'reifyDecl' { THReifyDecl }- 'reifyType' { THReifyType }- 'reifyFixity' { THReifyFixity }- Hsx -> PCDATA { XPcdata $$ }+> PCDATA { XPCDATA $$ } > '<' { XStdTagOpen } > '</' { XCloseTagOpen } > '<%' { XCodeTagOpen }@@ -172,7 +167,6 @@ > 'data' { KW_Data } > 'default' { KW_Default } > 'deriving' { KW_Deriving }- 'dlet' { KW_DLet } -- implicit parameter binding clause, no longer supported from 0.3.11 > 'do' { KW_Do } > 'else' { KW_Else } > 'family' { KW_Family } -- indexed type families@@ -193,7 +187,6 @@ > 'then' { KW_Then } > 'type' { KW_Type } > 'where' { KW_Where }- 'with' { KW_With } -- implicit parameter binding clause, no longer supported from 0.3.11 > 'qualified' { KW_Qualified } > %monad { P }@@ -206,34 +199,34 @@ ----------------------------------------------------------------------------- HSP Pages -> page :: { HsModule }-> : topxml {% mkPageModule $1 }-> | '<%' module '%>' srcloc topxml {% mkPage $2 $4 $5 }+> page :: { Module }+> : topxml {% checkExpr $1 >>= mkPageModule }+> | '<%' module '%>' srcloc topxml {% checkExpr $5 >>= \x -> mkPage $2 $4 x } > | module { $1 } -> topxml :: { HsExp }+> topxml :: { PExp } > : srcloc '<' name attrs mattr '>' children '</' name '>' {% do { n <- checkEqNames $3 $9; > let { cn = reverse $7; > as = reverse $4; };-> return $ HsXTag $1 n as $5 cn } }-> | srcloc '<' name attrs mattr '/>' { HsXETag $1 $3 (reverse $4) $5 }+> return $ XTag $1 n as $5 cn } }+> | srcloc '<' name attrs mattr '/>' { XETag $1 $3 (reverse $4) $5 } ----------------------------------------------------------------------------- Module Header -> module :: { HsModule }+> module :: { Module } > : srcloc 'module' modid maybeexports 'where' body-> { HsModule $1 $3 $4 (fst $6) (snd $6) }+> { Module $1 $3 $4 (fst $6) (snd $6) } > | srcloc body-> { HsModule $1 main_mod (Just [HsEVar (UnQual main_name)])+> { Module $1 main_mod (Just [EVar (UnQual main_name)]) > (fst $2) (snd $2) } -> body :: { ([HsImportDecl],[HsDecl]) }+> body :: { ([ImportDecl],[Decl]) } > : '{' bodyaux '}' { $2 } > | open bodyaux close { $2 } -> bodyaux :: { ([HsImportDecl],[HsDecl]) }+> bodyaux :: { ([ImportDecl],[Decl]) } > : optsemis impdecls semis topdecls { (reverse $2, $4) } > | optsemis topdecls { ([], $2) } > | optsemis impdecls optsemis { (reverse $2, []) }@@ -249,11 +242,11 @@ ----------------------------------------------------------------------------- The Export List -> maybeexports :: { Maybe [HsExportSpec] }+> maybeexports :: { Maybe [ExportSpec] } > : exports { Just $1 } > | {- empty -} { Nothing } -> exports :: { [HsExportSpec] }+> exports :: { [ExportSpec] } > : '(' exportlist optcomma ')' { reverse $2 } > | '(' optcomma ')' { [] } @@ -261,43 +254,43 @@ > : ',' { () } > | {- empty -} { () } -> exportlist :: { [HsExportSpec] }+> exportlist :: { [ExportSpec] } > : exportlist ',' export { $3 : $1 } > | export { [$1] } -> export :: { HsExportSpec }-> : qvar { HsEVar $1 }-> | qtyconorcls { HsEAbs $1 }-> | qtyconorcls '(' '..' ')' { HsEThingAll $1 }-> | qtyconorcls '(' ')' { HsEThingWith $1 [] }-> | qtyconorcls '(' cnames ')' { HsEThingWith $1 (reverse $3) }-> | 'module' modid { HsEModuleContents $2 }+> 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 :: { [HsImportDecl] }+> impdecls :: { [ImportDecl] } > : impdecls semis impdecl { $3 : $1 } > | impdecl { [$1] } -> impdecl :: { HsImportDecl }+> impdecl :: { ImportDecl } > : srcloc 'import' optqualified modid maybeas maybeimpspec-> { HsImportDecl $1 $4 $3 $5 $6 }+> { ImportDecl $1 $4 $3 $5 $6 } > optqualified :: { Bool } > : 'qualified' { True } > | {- empty -} { False } -> maybeas :: { Maybe Module }+> maybeas :: { Maybe ModuleName } > : 'as' modid { Just $2 } > | {- empty -} { Nothing } -> maybeimpspec :: { Maybe (Bool, [HsImportSpec]) }+> maybeimpspec :: { Maybe (Bool, [ImportSpec]) } > : impspec { Just $1 } > | {- empty -} { Nothing } -> impspec :: { (Bool, [HsImportSpec]) }+> impspec :: { (Bool, [ImportSpec]) } > : opthiding '(' importlist optcomma ')' { ($1, reverse $3) } > | opthiding '(' optcomma ')' { ($1, []) } @@ -305,41 +298,41 @@ > : 'hiding' { True } > | {- empty -} { False } -> importlist :: { [HsImportSpec] }+> importlist :: { [ImportSpec] } > : importlist ',' importspec { $3 : $1 } > | importspec { [$1] } -> importspec :: { HsImportSpec }-> : var { HsIVar $1 }-> | tyconorcls { HsIAbs $1 }-> | tyconorcls '(' '..' ')' { HsIThingAll $1 }-> | tyconorcls '(' ')' { HsIThingWith $1 [] }-> | tyconorcls '(' cnames ')' { HsIThingWith $1 (reverse $3) }+> importspec :: { ImportSpec }+> : var { IVar $1 }+> | tyconorcls { IAbs $1 }+> | tyconorcls '(' '..' ')' { IThingAll $1 }+> | tyconorcls '(' ')' { IThingWith $1 [] }+> | tyconorcls '(' cnames ')' { IThingWith $1 (reverse $3) } -> cnames :: { [HsCName] }+> cnames :: { [CName] } > : cnames ',' cname { $3 : $1 } > | cname { [$1] } -> cname :: { HsCName }-> : var { HsVarName $1 }-> | con { HsConName $1 }+> cname :: { CName }+> : var { VarName $1 }+> | con { ConName $1 } ----------------------------------------------------------------------------- Fixity Declarations -> fixdecl :: { HsDecl }-> : srcloc infix prec ops { HsInfixDecl $1 $2 $3 (reverse $4) }+> fixdecl :: { Decl }+> : srcloc infix prec ops { InfixDecl $1 $2 $3 (reverse $4) } > prec :: { Int } > : {- empty -} { 9 } > | INT {% checkPrec $1 } -> infix :: { HsAssoc }-> : 'infix' { HsAssocNone }-> | 'infixl' { HsAssocLeft }-> | 'infixr' { HsAssocRight }+> infix :: { Assoc }+> : 'infix' { AssocNone }+> | 'infixl' { AssocLeft }+> | 'infixr' { AssocRight } -> ops :: { [HsOp] }+> ops :: { [Op] } > : ops ',' op { $3 : $1 } > | op { [$1] } @@ -349,100 +342,99 @@ Note: The report allows topdecls to be empty. This would result in another shift/reduce-conflict, so we don't handle this case here, but in bodyaux. -> topdecls :: { [HsDecl] }+> topdecls :: { [Decl] } > : topdecls1 optsemis {% checkRevDecls $1 } -> topdecls1 :: { [HsDecl] }+> topdecls1 :: { [Decl] } > : topdecls1 semis topdecl { $3 : $1 } > | topdecl { [$1] } -> topdecl :: { HsDecl }+> topdecl :: { Decl } > : srcloc 'type' dtype '=' ctype > {% do { (c,ts) <- checkSimpleType $3;-> return (HsTypeDecl $1 c ts $5) } }+> return (TypeDecl $1 c ts $5) } } > | srcloc 'type' 'family' type optkind > {% do { (c,ts) <- checkSimpleType $4;-> return (HsTypeFamDecl $1 c ts $5) } }+> return (TypeFamDecl $1 c ts $5) } } > | srcloc 'type' 'instance' dtype '=' ctype > {% do { -- no checkSimpleType $4 since dtype may contain type patterns-> return (HsTypeInsDecl $1 $4 $6) } }+> return (TypeInsDecl $1 $4 $6) } } > | srcloc data_or_newtype ctype constrs0 deriving > {% do { (cs,c,t) <- checkDataHeader $3; > checkDataOrNew $2 $4;-> return (HsDataDecl $1 $2 cs c t (reverse $4) $5) } }+> return (DataDecl $1 $2 cs c t (reverse $4) $5) } } > | srcloc data_or_newtype ctype optkind 'where' gadtlist > {% do { (cs,c,t) <- checkDataHeader $3; > checkDataOrNew $2 $6;-> return (HsGDataDecl $1 $2 cs c t $4 (reverse $6)) } }+> return (GDataDecl $1 $2 cs c t $4 (reverse $6)) } } > | srcloc 'data' 'family' ctype optkind > {% do { (cs,c,t) <- checkDataHeader $4;-> return (HsDataFamDecl $1 cs c t $5) } }+> 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 (HsDataInsDecl $1 $2 $4 (reverse $5) $6) } }+> return (DataInsDecl $1 $2 $4 (reverse $5) $6) } } > | srcloc data_or_newtype 'instance' ctype optkind 'where' gadtlist > {% do { -- (cs,c,t) <- checkDataHeader $4; > checkDataOrNew $2 $7;-> return (HsGDataInsDecl $1 $2 $4 $5 (reverse $7)) } }+> return (GDataInsDecl $1 $2 $4 $5 (reverse $7)) } } > | srcloc 'class' ctype fds optcbody > {% do { (cs,c,vs) <- checkClassHeader $3;-> return (HsClassDecl $1 cs c vs $4 $5) } }+> return (ClassDecl $1 cs c vs $4 $5) } } > | srcloc 'instance' ctype optvaldefs > {% do { (cs,c,ts) <- checkInstHeader $3;-> return (HsInstDecl $1 cs c ts $4) } }+> return (InstDecl $1 cs c ts $4) } } > | srcloc 'deriving' 'instance' ctype > {% do { (cs, c, ts) <- checkInstHeader $4;-> return (HsDerivDecl $1 cs c ts) } }+> return (DerivDecl $1 cs c ts) } } > | srcloc 'default' '(' typelist ')'-> { HsDefaultDecl $1 $4 }-> | srcloc '$(' exp ')'-> {% do { e <- checkExpr $3;-> return $ HsSpliceDecl $1 $ HsParenSplice e } }+> { DefaultDecl $1 $4 }+> | srcloc '$(' trueexp ')'+> { SpliceDecl $1 $ ParenSplice $3 } > > | srcloc 'foreign' 'import' callconv safety fspec-> { let (s,n,t) = $6 in HsForImp $1 $4 $5 s n t }+> { let (s,n,t) = $6 in ForImp $1 $4 $5 s n t } > | srcloc 'foreign' 'export' callconv fspec-> { let (s,n,t) = $5 in HsForExp $1 $4 s n t }+> { let (s,n,t) = $5 in ForExp $1 $4 s n t } > | decl { $1 } > data_or_newtype :: { DataOrNew } > : 'data' { DataType } > | 'newtype' { NewType } -> typelist :: { [HsType] }+> typelist :: { [Type] } > : types { reverse $1 } > | type { [$1] } > | {- empty -} { [] } -> decls :: { [HsDecl] }+> decls :: { [Decl] } > : optsemis decls1 optsemis {% checkRevDecls $2 } > | optsemis { [] } -> decls1 :: { [HsDecl] }+> decls1 :: { [Decl] } > : decls1 semis decl { $3 : $1 } > | decl { [$1] } -> decl :: { HsDecl }+> decl :: { Decl } > : signdecl { $1 } > | fixdecl { $1 } > | valdef { $1 } -> decllist :: { [HsDecl] }+> decllist :: { [Decl] } > : '{' decls '}' { $2 } > | open decls close { $2 } -> signdecl :: { HsDecl }-> : srcloc vars '::' ctype { HsTypeSig $1 (reverse $2) $4 }+> signdecl :: { Decl }+> : srcloc vars '::' ctype { TypeSig $1 (reverse $2) $4 } Binding can be either of implicit parameters, or it can be a normal sequence of declarations. The two kinds cannot be mixed within the same block of binding. -> binds :: { HsBinds }-> : decllist { HsBDecls $1 }-> | '{' ipbinds '}' { HsIPBinds $2 }-> | open ipbinds close { HsIPBinds $2 }+> 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@@ -455,7 +447,7 @@ instead of a var only (which would be correct). But deciding what the + is, would require more lookahead. So let's check for ourselves... -> vars :: { [HsName] }+> vars :: { [Name] } > : vars ',' var { $3 : $1 } > | qvar {% do { n <- checkUnQual $1; > return [n] } }@@ -463,50 +455,50 @@ ----------------------------------------------------------------------------- FFI -> callconv :: { HsCallConv }+> callconv :: { CallConv } > : 'stdcall' { StdCall } > | 'ccall' { CCall } -> safety :: { HsSafety }+> safety :: { Safety } > : 'safe' { PlaySafe False } > | 'unsafe' { PlayRisky } > | 'threadsafe' { PlaySafe True } > | {- empty -} { PlaySafe False } -> fspec :: { (String, HsName, HsType) }+> fspec :: { (String, Name, Type) } > : STRING var_no_safety '::' dtype { ($1, $2, $4) } > | var_no_safety '::' dtype { ("", $1, $3) } ----------------------------------------------------------------------------- Types -> dtype :: { HsType }+> dtype :: { Type } > : btype { $1 }-> | btype qtyconop dtype { HsTyInfix $1 $2 $3 }-> | btype qtyvarop dtype { HsTyInfix $1 $2 $3 }-> | btype '->' dtype { HsTyFun $1 $3 }-> | btype '~' btype { HsTyPred $ HsEqualP $1 $3 }+> | 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 :: { HsType }-> : ivar '::' dtype { HsTyPred $ HsIParam $1 $3 }+> type :: { Type }+> : ivar '::' dtype { TyPred $ IParam $1 $3 } > | dtype { $1 } -> btype :: { HsType }-> : btype atype { HsTyApp $1 $2 }+> btype :: { Type }+> : btype atype { TyApp $1 $2 } > | atype { $1 } -> atype :: { HsType }-> : gtycon { HsTyCon $1 }-> | tyvar { HsTyVar $1 }-> | '(' types ')' { HsTyTuple Boxed (reverse $2) }-> | '(#' types1 '#)' { HsTyTuple Unboxed (reverse $2) }-> | '[' type ']' { HsTyApp list_tycon $2 }+> 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 ')' { HsTyKind $2 $4 }+> | '(' ctype '::' kind ')' { TyKind $2 $4 } -> gtycon :: { HsQName }+> gtycon :: { QName } > : qconid { $1 } > | '(' ')' { unit_tycon_name } > | '(' '->' ')' { fun_tycon_name }@@ -515,7 +507,7 @@ These are for infix types -> qtyconop :: { HsQName }+> qtyconop :: { QName } > : qconop { $1 } @@ -532,34 +524,31 @@ (more specifically as a tuple type), then check that it has the right form C a, or (C1 a, C2 b, ... Cn z) and convert it into a context. Blaach! -> ctype :: { HsType }-> : 'forall' ktyvars '.' ctype { mkHsTyForall (Just $2) [] $4 }-> | context '=>' type { mkHsTyForall Nothing $1 $3 }+> ctype :: { Type }+> : 'forall' ktyvars '.' ctype { mkTyForall (Just $2) [] $4 }+> | context '=>' type { mkTyForall Nothing $1 $3 } > | type { $1 } -> context :: { HsContext }+> context :: { Context } > : btype {% checkContext $1 }-> | btype '~' btype {% checkContext (HsTyPred $ HsEqualP $1 $3) }+> | btype '~' btype {% checkContext (TyPred $ EqualP $1 $3) } -> types :: { [HsType] }+> types :: { [Type] } > : types1 ',' type { $3 : $1 } -> types1 :: { [HsType] }+> types1 :: { [Type] } > : type { [$1] } > | types1 ',' type { $3 : $1 } - simpletype :: { (HsName, [HsName]) }- : tycon tyvars { ($1,reverse $2) }--> ktyvars :: { [HsTyVarBind] }+> ktyvars :: { [TyVarBind] } > : ktyvars ktyvar { $2 : $1 } > | {- empty -} { [] } -> ktyvar :: { HsTyVarBind }-> : tyvar { HsUnkindedVar $1 }-> | '(' tyvar '::' kind ')' { HsKindedVar $2 $4 }+> ktyvar :: { TyVarBind }+> : tyvar { UnkindedVar $1 }+> | '(' tyvar '::' kind ')' { KindedVar $2 $4 } -> tyvars :: { [HsName] }+> tyvars :: { [Name] } > : tyvars tyvar { $2 : $1 } > | {- empty -} { [] } @@ -567,205 +556,203 @@ ----------------------------------------------------------------------------- Functional Dependencies -> fds :: { [HsFunDep] }+> fds :: { [FunDep] } > : {- empty -} { [] } > | '|' fds1 { reverse $2 } -> fds1 :: { [HsFunDep] }+> fds1 :: { [FunDep] } > : fds1 ',' fd { $3 : $1 } > | fd { [$1] } -> fd :: { HsFunDep }-> : tyvars '->' tyvars { HsFunDep (reverse $1) (reverse $3) }+> fd :: { FunDep }+> : tyvars '->' tyvars { FunDep (reverse $1) (reverse $3) } ----------------------------------------------------------------------------- Datatype declarations GADTs -> gadtlist :: { [HsGadtDecl] }+> gadtlist :: { [GadtDecl] } > : '{' gadtconstrs1 '}' { $2 } > | open gadtconstrs1 close { $2 } -> gadtconstrs1 :: { [HsGadtDecl] }+> gadtconstrs1 :: { [GadtDecl] } > : optsemis gadtconstrs optsemis { $2 } -> gadtconstrs :: { [HsGadtDecl] }+> gadtconstrs :: { [GadtDecl] } > : gadtconstrs semis gadtconstr { $3 : $1 } > | gadtconstr { [$1] } -> gadtconstr :: { HsGadtDecl }+> gadtconstr :: { GadtDecl } > : srcloc qcon '::' ctype {% do { c <- checkUnQual $2;-> return $ HsGadtDecl $1 c $4 } }+> return $ GadtDecl $1 c $4 } } -> constrs0 :: { [HsQualConDecl] }+> constrs0 :: { [QualConDecl] } > : {- empty -} { [] } > | '=' constrs { $2 } -> constrs :: { [HsQualConDecl] }+> constrs :: { [QualConDecl] } > : constrs '|' constr { $3 : $1 } > | constr { [$1] } -> constr :: { HsQualConDecl }-> : srcloc forall context '=>' constr1 { HsQualConDecl $1 $2 $3 $5 }-> | srcloc forall constr1 { HsQualConDecl $1 $2 [] $3 }+> constr :: { QualConDecl }+> : srcloc forall context '=>' constr1 { QualConDecl $1 $2 $3 $5 }+> | srcloc forall constr1 { QualConDecl $1 $2 [] $3 } -> forall :: { [HsTyVarBind] }+> forall :: { [TyVarBind] } > : 'forall' ktyvars '.' { $2 } > | {- empty -} { [] } -> constr1 :: { HsConDecl }-> : scontype { HsConDecl (fst $1) (snd $1) }-> | sbtype conop sbtype { HsConDecl $2 [$1,$3] }-> | con '{' '}' { HsRecDecl $1 [] }-> | con '{' fielddecls '}' { HsRecDecl $1 (reverse $3) }+> 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 :: { (HsName, [HsBangType]) }+> scontype :: { (Name, [BangType]) } > : btype {% do { (c,ts) <- splitTyConApp $1;-> return (c,map HsUnBangedTy ts) } }+> return (c,map UnBangedTy ts) } } > | scontype1 { $1 } -> scontype1 :: { (HsName, [HsBangType]) }+> scontype1 :: { (Name, [BangType]) } > : btype '!' atype {% do { (c,ts) <- splitTyConApp $1;-> return (c,map HsUnBangedTy ts++-> [HsBangedTy $3]) } }+> return (c,map UnBangedTy ts+++> [BangedTy $3]) } } > | scontype1 satype { (fst $1, snd $1 ++ [$2] ) } -> satype :: { HsBangType }-> : atype { HsUnBangedTy $1 }-> | '!' atype { HsBangedTy $2 }+> satype :: { BangType }+> : atype { UnBangedTy $1 }+> | '!' atype { BangedTy $2 } -> sbtype :: { HsBangType }-> : btype { HsUnBangedTy $1 }-> | '!' atype { HsBangedTy $2 }+> sbtype :: { BangType }+> : btype { UnBangedTy $1 }+> | '!' atype { BangedTy $2 } -> fielddecls :: { [([HsName],HsBangType)] }+> fielddecls :: { [([Name],BangType)] } > : fielddecls ',' fielddecl { $3 : $1 } > | fielddecl { [$1] } -> fielddecl :: { ([HsName],HsBangType) }+> fielddecl :: { ([Name],BangType) } > : vars '::' stype { (reverse $1, $3) } -> stype :: { HsBangType }-> : ctype { HsUnBangedTy $1 } -> | '!' atype { HsBangedTy $2 }+> stype :: { BangType }+> : ctype { UnBangedTy $1 } +> | '!' atype { BangedTy $2 } -> deriving :: { [HsQName] }+> deriving :: { [QName] } > : {- empty -} { [] } > | 'deriving' qtycls { [$2] } > | 'deriving' '(' ')' { [] } > | 'deriving' '(' dclasses ')' { reverse $3 } -> dclasses :: { [HsQName] }+> dclasses :: { [QName] } > : dclasses ',' qtycls { $3 : $1 } > | qtycls { [$1] } ----------------------------------------------------------------------------- Kinds -> kind :: { HsKind }+> kind :: { Kind } > : akind { $1 }-> | akind '->' kind { HsKindFn $1 $3 }+> | akind '->' kind { KindFn $1 $3 } -> akind :: { HsKind }-> : '*' { HsKindStar }-> | '!' { HsKindBang }+> akind :: { Kind }+> : '*' { KindStar }+> | '!' { KindBang } > | '(' kind ')' { $2 } -> optkind :: { Maybe HsKind }+> optkind :: { Maybe Kind } > : {-empty-} { Nothing } > | '::' kind { Just $2 } ----------------------------------------------------------------------------- Class declarations No implicit parameters in the where clause of a class declaration.-> optcbody :: { [HsClassDecl] }+> optcbody :: { [ClassDecl] } > : 'where' cldecllist {% checkClassBody $2 } > | {- empty -} { [] } -> cldecllist :: { [HsClassDecl] }+> cldecllist :: { [ClassDecl] } > : '{' cldecls '}' { $2 } > | open cldecls close { $2 } -> cldecls :: { [HsClassDecl] }+> cldecls :: { [ClassDecl] } > : optsemis cldecls1 optsemis {% checkRevClsDecls $2 } > | optsemis { [] } -> cldecls1 :: { [HsClassDecl] }+> cldecls1 :: { [ClassDecl] } > : cldecls1 semis cldecl { $3 : $1 } > | cldecl { [$1] } -> cldecl :: { HsClassDecl }-> : decl { HsClsDecl $1 }+> cldecl :: { ClassDecl }+> : decl { ClsDecl $1 } > | atdecl { $1 } -> atdecl :: { HsClassDecl }+> atdecl :: { ClassDecl } > : srcloc 'type' type optkind > {% do { (c,ts) <- checkSimpleType $3;-> return (HsClsTyFam $1 c ts $4) } }+> return (ClsTyFam $1 c ts $4) } } > | srcloc 'type' dtype '=' ctype-> { HsClsTyDef $1 $3 $5 }+> { ClsTyDef $1 $3 $5 } > | srcloc 'data' ctype optkind > {% do { (cs,c,t) <- checkDataHeader $3;-> return (HsClsDataFam $1 cs c t $4) } }+> return (ClsDataFam $1 cs c t $4) } } ----------------------------------------------------------------------------- Instance declarations -> optvaldefs :: { [HsInstDecl] }+> optvaldefs :: { [InstDecl] } > : 'where' '{' valdefs '}' {% checkInstBody $3 } > | 'where' open valdefs close {% checkInstBody $3 } > | {- empty -} { [] } -> valdefs :: { [HsInstDecl] }+> valdefs :: { [InstDecl] } > : optsemis valdefs1 optsemis {% checkRevInstDecls $2 } > | optsemis { [] } -> valdefs1 :: { [HsInstDecl] }+> valdefs1 :: { [InstDecl] } > : valdefs1 semis insvaldef { $3 : $1 } > | insvaldef { [$1] } -> insvaldef :: { HsInstDecl }-> : valdef { HsInsDecl $1 }+> insvaldef :: { InstDecl }+> : valdef { InsDecl $1 } > | atinst { $1 } -> atinst :: { HsInstDecl }+> atinst :: { InstDecl } > : srcloc 'type' dtype '=' ctype > {% do { -- no checkSimpleType $4 since dtype may contain type patterns-> return (HsInsType $1 $3 $5) } }+> return (InsType $1 $3 $5) } } > | srcloc data_or_newtype ctype constrs0 deriving > {% do { -- (cs,c,t) <- checkDataHeader $4; > checkDataOrNew $2 $4;-> return (HsInsData $1 $2 $3 (reverse $4) $5) } }+> return (InsData $1 $2 $3 (reverse $4) $5) } } > | srcloc data_or_newtype ctype optkind 'where' gadtlist > {% do { -- (cs,c,t) <- checkDataHeader $4; > checkDataOrNew $2 $6;-> return (HsInsGData $1 $2 $3 $4 (reverse $6)) } }+> return (InsGData $1 $2 $3 $4 (reverse $6)) } } ----------------------------------------------------------------------------- Value definitions -> valdef :: { HsDecl }+> valdef :: { Decl } > : srcloc exp0b rhs optwhere {% checkValDef $1 $2 $3 $4 } May bind implicit parameters-> optwhere :: { HsBinds }+> optwhere :: { Binds } > : 'where' binds { $2 }-> | {- empty -} { HsBDecls [] }+> | {- empty -} { BDecls [] } -> rhs :: { HsRhs }-> : '=' exp {% do { e <- checkExpr $2;-> return (HsUnGuardedRhs e) } }-> | gdrhs { HsGuardedRhss (reverse $1) }+> rhs :: { Rhs }+> : '=' trueexp { UnGuardedRhs $2 }+> | gdrhs { GuardedRhss (reverse $1) } -> gdrhs :: { [HsGuardedRhs] }+> gdrhs :: { [GuardedRhs] } > : gdrhs gdrh { $2 : $1 } > | gdrh { [$1] } Guards may contain patterns, hence quals instead of exp.-> gdrh :: { HsGuardedRhs }-> : srcloc '|' quals '=' exp {% do { e <- checkExpr $5;-> return (HsGuardedRhs $1 (reverse $3) e) } }+> gdrh :: { GuardedRhs }+> : srcloc '|' quals '=' trueexp { GuardedRhs $1 (reverse $3) $5 } ----------------------------------------------------------------------------- Expressions@@ -779,49 +766,53 @@ can followed by a type signature or infix application. So we duplicate the exp0 productions to distinguish these from the others (exp0a). -> exp :: { HsExp }-> : exp0b '::' srcloc ctype { HsExpTypeSig $3 $1 $4 }- | exp0b 'with' ipbinding { HsWith $1 $3 } -- implicit parameters (hugs), no longer supported+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 { HsPostOp $1 $2 } -- for HaRP's sake+> | exp0b qop { PostOp $1 $2 } -> exp0 :: { HsExp }+> exp0 :: { PExp } > : exp0a { $1 } > | exp0b { $1 } -> exp0a :: { HsExp }-> : exp0b qop exp10a { HsInfixApp $1 $2 $3 }+> exp0a :: { PExp }+> : exp0b qop exp10a { InfixApp $1 $2 $3 } > | exp10a { $1 } -> exp0b :: { HsExp }-> : exp0b qop exp10b { HsInfixApp $1 $2 $3 }+> exp0b :: { PExp }+> : exp0b qop exp10b { InfixApp $1 $2 $3 } > | dvarexp { $1 } > | exp10b { $1 } -> exp10a :: { HsExp }-> : '\\' srcloc apats '->' exp { HsLambda $2 (reverse $3) $5 }+> exp10a :: { PExp }+> : '\\' srcloc apats '->' exp { Lambda $2 (reverse $3) $5 } A let may bind implicit parameters-> | 'let' binds 'in' exp { HsLet $2 $4 }- | 'dlet' ipbinding 'in' exp { HsDLet $2 $4 } -- no longer supported-> | 'if' exp 'then' exp 'else' exp { HsIf $2 $4 $6 }+> | 'let' binds 'in' exp { Let $2 $4 }+> | 'if' exp 'then' exp 'else' exp { If $2 $4 $6 } -> exp10b :: { HsExp }-> : 'case' exp 'of' altslist { HsCase $2 $4 }-> | '-' fexp { HsNegApp $2 }-> | 'do' stmtlist { HsDo $2 }-> | 'mdo' stmtlist { HsMDo $2 }- | reifyexp { HsReifyExp $1 }+> exp10b :: { PExp }+> : 'case' exp 'of' altslist { Case $2 $4 }+> | '-' fexp { NegApp $2 }+> | 'do' stmtlist { Do $2 }+> | 'mdo' stmtlist { MDo $2 } > | fexp { $1 } -> fexp :: { HsExp }-> : fexp aexp { HsApp $1 $2 }+> fexp :: { PExp }+> : fexp aexp { App $1 $2 } > | aexp { $1 } -> apats :: { [HsPat] }+> apats :: { [Pat] } > : apats apat { $2 : $1 } > | apat { [$1] } -> apat :: { HsPat }+> apat :: { Pat } > : aexp {% checkPattern $1 } UGLY: Because patterns and expressions are mixed, aexp has to be split into@@ -832,18 +823,18 @@ qvar here to avoid a shift/reduce conflict, and then check it ourselves (as for vars above). -> aexp :: { HsExp }+> aexp :: { PExp } > : qvar '@' aexp {% do { n <- checkUnQual $1;-> return (HsAsPat n $3) } }+> return (AsPat n $3) } } > | qvar '@:' aexp {% do { n <- checkUnQual $1;-> return (HsCAsRP n $3) } }-> | '~' aexp { HsIrrPat $2 }+> 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 :: { HsExp }+> aexp1 :: { PExp } > : aexp1 '{' '}' {% mkRecConstrOrUpdate $1 [] } > | aexp1 '{' fbinds '}' {% mkRecConstrOrUpdate $1 (reverse $3) } > | aexp2 { $1 }@@ -852,93 +843,80 @@ parses equivalently to ((e) op x). Thus e must be an exp0b. An implicit parameter can be used as an expression. -> aexp2 :: { HsExp }-> : ivar { HsIPVar $1 }-> | qvar { HsVar $1 }+> aexp2 :: { PExp }+> : ivar { IPVar $1 }+> | qvar { Var $1 } > | gcon { $1 }-> | literal { HsLit $1 }-> | '(' exp ')' { HsParen $2 }-> | '(' texps ')' { HsTuple (reverse $2) }+> | literal { Lit $1 }+> | '(' exp ')' { Paren $2 }+> | '(' texps ')' { Tuple (reverse $2) } > | '[' list ']' { $2 }- | '(' exp0b rqop ')' { HsLeftSection $2 $3 }-> | '(' qopm exp0 ')' { HsRightSection $2 $3 }-> | '_' { HsWildCard }+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 '|)' { HsSeqRP $ reverse $2 }-> | '(|' exp '|' quals '|)' { HsGuardRP $2 $ reverse $4 }+> | '(|' sexps '|)' { SeqRP $ reverse $2 }+> | '(|' exp '|' quals '|)' { GuardRP $2 $ reverse $4 } > | xml { $1 } Template Haskell-> | IDSPLICE { HsSpliceExp $ HsIdSplice $1 }-> | '$(' exp ')' {% do { e <- checkExpr $2;-> return $ HsSpliceExp $ HsParenSplice e } }-> | '[|' exp '|]' {% do { e <- checkExpr $2;-> return $ HsBracketExp $ HsExpBracket e } }+> | IDSPLICE { SpliceExp $ IdSplice $1 }+> | '$(' trueexp ')' { SpliceExp $ ParenSplice $2 }+> | '[|' trueexp '|]' { BracketExp $ ExpBracket $2 } > | '[p|' exp0 '|]' {% do { p <- checkPattern $2;-> return $ HsBracketExp $ HsPatBracket p } }-> | '[t|' ctype '|]' { HsBracketExp $ HsTypeBracket $2 }-> | '[d|' open topdecls close '|]' { HsBracketExp $ HsDeclBracket $3 }-> | VARQUOTE qvar { HsVarQuote $2 }-> | VARQUOTE qcon { HsVarQuote $2 }-> | TYPQUOTE tyvar { HsTypQuote (UnQual $2) }-> | TYPQUOTE gtycon { HsTypQuote $2 }--- reifyexp :: { HsReify }- : 'reifyDecl' gtycon { HsReifyDecl $2 }- | 'reifyDecl' qvar { HsReifyDecl $2 }- | 'reifyType' qcname { HsReifyType $2 }- | 'reifyFixity' qcname { HsReifyFixity $2 }--- qcname :: { HsQName }- : qvar { $1 }- | gcon {% getGConName $1 }+> 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 :: { [HsExp] }+> texps :: { [PExp] } > : texps ',' exp { $3 : $1 } > | exp ',' exp { [$3,$1] } ----------------------------------------------------------------------------- Harp Extensions -> sexps :: { [HsExp] }+> sexps :: { [PExp] } > : sexps ',' exp { $3 : $1 } > | exp { [$1] } Either patterns are left associative-> erpats :: { HsExp }-> : exp '|' erpats { HsEitherRP $1 $3 }-> | exp '|' exp { HsEitherRP $1 $3 }+> erpats :: { PExp }+> : exp '|' erpats { EitherRP $1 $3 }+> | exp '|' exp { EitherRP $1 $3 } ----------------------------------------------------------------------------- Hsx Extensions -> xml :: { HsExp }+> xml :: { PExp } > : srcloc '<' name attrs mattr '>' children '</' name '>' {% do { n <- checkEqNames $3 $9; > let { cn = reverse $7; > as = reverse $4; };-> return $ HsXTag $1 n as $5 cn } }-> | srcloc '<' name attrs mattr '/>' { HsXETag $1 $3 (reverse $4) $5 }-> | '<%' exp '%>' { HsXExpTag $2 }+> return $ XTag $1 n as $5 cn } }+> | srcloc '<' name attrs mattr '/>' { XETag $1 $3 (reverse $4) $5 }+> | '<%' exp '%>' { XExpTag $2 } -> children :: { [HsExp] }+> children :: { [PExp] } > : children child { $2 : $1 } > | {- empty -} { [] } -> child :: { HsExp }-> : PCDATA { HsXPcdata $1 }-> | '<[' sexps ']>' { HsXRPats $ reverse $2 }+> child :: { PExp }+> : PCDATA { XPcdata $1 }+> | '<[' sexps ']>' { XRPats $ reverse $2 } > | xml { $1 } -> name :: { HsXName }-> : xmlname ':' xmlname { HsXDomName $1 $3 }-> | xmlname { HsXName $1 }+> name :: { XName }+> : xmlname ':' xmlname { XDomName $1 $3 }+> | xmlname { XName $1 } > xmlname :: { String } > : VARID { $1 }@@ -947,19 +925,19 @@ > | 'type' { "type" } > | 'class' { "class" } -> attrs :: { [HsXAttr] }+> attrs :: { [ParseXAttr] } > : attrs attr { $2 : $1 } > | {- empty -} { [] } -> attr :: { HsXAttr }-> : name '=' aexp { HsXAttr $1 $3 }+> attr :: { ParseXAttr }+> : name '=' aexp { XAttr $1 $3 } -> mattr :: { Maybe HsExp }+> mattr :: { Maybe PExp } > : aexp { Just $1 } > | {-empty-} { Nothing } Turning dash variables into infix expressions with '-'-> dvarexp :: { HsExp }+> dvarexp :: { PExp } > : DVARID { mkDVarExpr $1 } -----------------------------------------------------------------------------@@ -968,64 +946,64 @@ The rules below are little bit contorted to keep lexps left-recursive while avoiding another shift/reduce-conflict. -> list :: { HsExp }-> : exp { HsList [$1] }-> | lexps { HsList (reverse $1) }-> | exp '..' { HsEnumFrom $1 }-> | exp ',' exp '..' { HsEnumFromThen $1 $3 }-> | exp '..' exp { HsEnumFromTo $1 $3 }-> | exp ',' exp '..' exp { HsEnumFromThenTo $1 $3 $5 }-> | exp '|' quals { HsListComp $1 (reverse $3) }+> list :: { PExp }+> : exp { List [$1] }+> | lexps { List (reverse $1) }+> | exp '..' { EnumFrom $1 }+> | exp ',' exp '..' { EnumFromThen $1 $3 }+> | exp '..' exp { EnumFromTo $1 $3 }+> | exp ',' exp '..' exp { EnumFromThenTo $1 $3 $5 }+> | exp '|' quals { ListComp $1 (reverse $3) } -> lexps :: { [HsExp] }+> lexps :: { [PExp] } > : lexps ',' exp { $3 : $1 } > | exp ',' exp { [$3,$1] } ----------------------------------------------------------------------------- List comprehensions -> quals :: { [HsStmt] }-> : quals1 {% mapM checkStmt $1 }+ quals :: { [Stmt] }+ : quals1 {% mapM checkStmt $1 } -> quals1 :: { [HsStmt] }-> : quals1 ',' qual { $3 : $1 }+> quals :: { [Stmt] }+> : quals ',' qual { $3 : $1 } > | qual { [$1] } -> qual :: { HsStmt }-> : pat srcloc '<-' exp { HsGenerator $2 $1 $4 }-> | exp { HsQualifier $1 }-> | 'let' binds { HsLetStmt $2 }+> qual :: { Stmt }+> : pat srcloc '<-' trueexp { Generator $2 $1 $4 }+> | trueexp { Qualifier $1 }+> | 'let' binds { LetStmt $2 } ----------------------------------------------------------------------------- Case alternatives -> altslist :: { [HsAlt] }+> altslist :: { [Alt] } > : '{' alts '}' { $2 } > | open alts close { $2 } -> alts :: { [HsAlt] }+> alts :: { [Alt] } > : optsemis alts1 optsemis { reverse $2 } -> alts1 :: { [HsAlt] }+> alts1 :: { [Alt] } > : alts1 semis alt { $3 : $1 } > | alt { [$1] } -> alt :: { HsAlt }-> : srcloc pat ralt optwhere { HsAlt $1 $2 $3 $4 }+> alt :: { Alt }+> : srcloc pat ralt optwhere { Alt $1 $2 $3 $4 } -> ralt :: { HsGuardedAlts }-> : '->' exp { HsUnGuardedAlt $2 }-> | gdpats { HsGuardedAlts (reverse $1) }+> ralt :: { GuardedAlts }+> : '->' trueexp { UnGuardedAlt $2 }+> | gdpats { GuardedAlts (reverse $1) } -> gdpats :: { [HsGuardedAlt] }+> gdpats :: { [GuardedAlt] } > : gdpats gdpat { $2 : $1 } > | gdpat { [$1] } A guard can be a pattern guard, hence quals instead of exp0.-> gdpat :: { HsGuardedAlt }-> : srcloc '|' quals '->' exp { HsGuardedAlt $1 (reverse $3) $5 }+> gdpat :: { GuardedAlt }+> : srcloc '|' quals '->' trueexp { GuardedAlt $1 (reverse $3) $5 } -> pat :: { HsPat }+> pat :: { Pat } > : exp0b {% checkPattern $1 } -----------------------------------------------------------------------------@@ -1035,124 +1013,120 @@ without introducing conflicts. This also ensures that the last stmt is an expression. -> stmtlist :: { [HsStmt] }+> stmtlist :: { [Stmt] } > : '{' stmts '}' { $2 } > | open stmts close { $2 } A let statement may bind implicit parameters.-> stmts :: { [HsStmt] }-> : 'let' binds ';' stmts { HsLetStmt $2 : $4 }-> | pat srcloc '<-' exp ';' stmts { HsGenerator $2 $1 $4 : $6 }-> | exp ';' stmts { HsQualifier $1 : $3 }-> | ';' stmts { $2 }-> | exp ';' { [HsQualifier $1] }-> | exp { [HsQualifier $1] }+> 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 :: { [HsFieldUpdate] }+> fbinds :: { [PFieldUpdate] } > : fbinds ',' fbind { $3 : $1 } > | fbind { [$1] } -> fbind :: { HsFieldUpdate }-> : qvar '=' exp { HsFieldUpdate $1 $3 }+> fbind :: { PFieldUpdate }+> : qvar '=' exp { FieldUpdate $1 $3 } ----------------------------------------------------------------------------- Implicit parameter bindings - ipbinding :: { [HsIPBind] }- : '{' ipbinds '}' { $2 }- | open ipbinds close { $2 }--> ipbinds :: { [HsIPBind] }+> ipbinds :: { [IPBind] } > : optsemis ipbinds1 optsemis { reverse $2 } -> ipbinds1 :: { [HsIPBind] }+> ipbinds1 :: { [IPBind] } > : ipbinds1 semis ipbind { $3 : $1 } > | ipbind { [$1] } -> ipbind :: { HsIPBind }-> : srcloc ivar '=' exp { HsIPBind $1 $2 $4 }+> ipbind :: { IPBind }+> : srcloc ivar '=' trueexp { IPBind $1 $2 $4 } ----------------------------------------------------------------------------- Variables, Constructors and Operators. -> gcon :: { HsExp }-> : '(' ')' { unit_con }-> | '[' ']' { HsList [] }-> | '(' commas ')' { tuple_con $2 }-> | qcon { HsCon $1 }+> gcon :: { PExp }+> : '(' ')' { p_unit_con }+> | '[' ']' { List [] }+> | '(' commas ')' { p_tuple_con $2 }+> | qcon { Con $1 } -> var :: { HsName }+> var :: { Name } > : varid { $1 } > | '(' varsym ')' { $2 } -> var_no_safety :: { HsName }+> var_no_safety :: { Name } > : varid_no_safety { $1 } > | '(' varsym ')' { $2 } -> qvar :: { HsQName }+> qvar :: { QName } > : qvarid { $1 } > | '(' qvarsym ')' { $2 } Implicit parameter-> ivar :: { HsIPName }+> ivar :: { IPName } > : ivarid { $1 } -> con :: { HsName }+> con :: { Name } > : conid { $1 } > | '(' consym ')' { $2 } -> qcon :: { HsQName }+> qcon :: { QName } > : qconid { $1 } > | '(' gconsym ')' { $2 } -> varop :: { HsName }+> varop :: { Name } > : varsym { $1 } > | '`' varid '`' { $2 } -> qvarop :: { HsQName }+> qvarop :: { QName } > : qvarsym { $1 } > | '`' qvarid '`' { $2 } -> qvaropm :: { HsQName }+> qvaropm :: { QName } > : qvarsymm { $1 } > | '`' qvarid '`' { $2 } -> conop :: { HsName }+> conop :: { Name } > : consym { $1 } > | '`' conid '`' { $2 } -> qconop :: { HsQName }+> qconop :: { QName } > : gconsym { $1 } > | '`' qconid '`' { $2 } -> op :: { HsOp }-> : varop { HsVarOp $1 }-> | conop { HsConOp $1 }+> op :: { Op }+> : varop { VarOp $1 }+> | conop { ConOp $1 } -> qop :: { HsQOp }-> : qvarop { HsQVarOp $1 }-> | qconop { HsQConOp $1 }+> qop :: { QOp }+> : qvarop { QVarOp $1 }+> | qconop { QConOp $1 } -> qopm :: { HsQOp }-> : qvaropm { HsQVarOp $1 }-> | qconop { HsQConOp $1 }+> qopm :: { QOp }+> : qvaropm { QVarOp $1 }+> | qconop { QConOp $1 } -> gconsym :: { HsQName }+> gconsym :: { QName } > : ':' { list_cons_name } > | qconsym { $1 } ----------------------------------------------------------------------------- Identifiers and Symbols -> qvarid :: { HsQName }+> qvarid :: { QName } > : varid { UnQual $1 }-> | QVARID { Qual (Module (fst $1)) (HsIdent (snd $1)) }+> | QVARID { Qual (ModuleName (fst $1)) (Ident (snd $1)) } -> varid_no_safety :: { HsName }-> : VARID { HsIdent $1 }+> varid_no_safety :: { Name }+> : VARID { Ident $1 } > | 'as' { as_name } > | 'qualified' { qualified_name } > | 'hiding' { hiding_name }@@ -1160,7 +1134,7 @@ > | 'stdcall' { stdcall_name } > | 'ccall' { ccall_name } -> varid :: { HsName }+> varid :: { Name } > : varid_no_safety { $1 } > | 'safe' { safe_name } > | 'unsafe' { unsafe_name }@@ -1168,53 +1142,53 @@ Implicit parameter-> ivarid :: { HsIPName }-> : IDUPID { HsIPDup $1 }-> | ILINID { HsIPLin $1 }+> ivarid :: { IPName }+> : IDUPID { IPDup $1 }+> | ILINID { IPLin $1 } -> qconid :: { HsQName }+> qconid :: { QName } > : conid { UnQual $1 }-> | QCONID { Qual (Module (fst $1)) (HsIdent (snd $1)) }+> | QCONID { Qual (ModuleName (fst $1)) (Ident (snd $1)) } -> conid :: { HsName }-> : CONID { HsIdent $1 }+> conid :: { Name }+> : CONID { Ident $1 } -> qconsym :: { HsQName }+> qconsym :: { QName } > : consym { UnQual $1 }-> | QCONSYM { Qual (Module (fst $1)) (HsSymbol (snd $1)) }+> | QCONSYM { Qual (ModuleName (fst $1)) (Symbol (snd $1)) } -> consym :: { HsName }-> : CONSYM { HsSymbol $1 }+> consym :: { Name }+> : CONSYM { Symbol $1 } -> qvarsym :: { HsQName }+> qvarsym :: { QName } > : varsym { UnQual $1 } > | qvarsym1 { $1 } -> qvarsymm :: { HsQName }+> qvarsymm :: { QName } > : varsymm { UnQual $1 } > | qvarsym1 { $1 } -> varsym :: { HsName }-> : VARSYM { HsSymbol $1 }+> varsym :: { Name }+> : VARSYM { Symbol $1 } > | '-' { minus_name } > | '!' { pling_name } > | '.' { dot_name } > | '*' { star_name } -> varsymm :: { HsName } -- varsym not including '-'-> : VARSYM { HsSymbol $1 }+> varsymm :: { Name } -- varsym not including '-'+> : VARSYM { Symbol $1 } > | '!' { pling_name } > | '.' { dot_name } > | '*' { star_name } -> qvarsym1 :: { HsQName }-> : QVARSYM { Qual (Module (fst $1)) (HsSymbol (snd $1)) }+> qvarsym1 :: { QName }+> : QVARSYM { Qual (ModuleName (fst $1)) (Symbol (snd $1)) } -> literal :: { HsLiteral }-> : INT { HsInt $1 }-> | CHAR { HsChar $1 }-> | RATIONAL { HsFrac $1 }-> | STRING { HsString $1 }+> literal :: { Literal }+> : INT { Int $1 }+> | CHAR { Char $1 }+> | RATIONAL { Frac $1 }+> | STRING { String $1 } > srcloc :: { SrcLoc } : {% getSrcLoc } @@ -1230,31 +1204,31 @@ ----------------------------------------------------------------------------- Miscellaneous (mostly renamings) -> modid :: { Module }-> : CONID { Module $1 }-> | QCONID { Module (fst $1 ++ '.':snd $1) }+> modid :: { ModuleName }+> : CONID { ModuleName $1 }+> | QCONID { ModuleName (fst $1 ++ '.':snd $1) } -> tyconorcls :: { HsName }+> tyconorcls :: { Name } > : conid { $1 } - tycon :: { HsName }+ tycon :: { Name } : conid { $1 } -> qtyconorcls :: { HsQName }+> qtyconorcls :: { QName } > : qconid { $1 } -> qtycls :: { HsQName }+> qtycls :: { QName } > : qconid { $1 } -> tyvar :: { HsName }+> tyvar :: { Name } > : varid { $1 } -> qtyvarop :: { HsQName }+> qtyvarop :: { QName } > qtyvarop : '`' tyvar '`' { UnQual $2 } > | tyvarsym { UnQual $1 } -> tyvarsym :: { HsName }-> tyvarsym : VARSYM { HsSymbol $1 }+> tyvarsym :: { Name }+> tyvarsym : VARSYM { Symbol $1 } ----------------------------------------------------------------------------- @@ -1263,10 +1237,10 @@ > happyError = fail "Parse error" > -- | Parse of a string, which should contain a complete Haskell 98 module.-> parseModule :: String -> ParseResult HsModule+> parseModule :: String -> ParseResult Module > parseModule = runParser parse > -- | Parse of a string, which should contain a complete Haskell 98 module.-> parseModuleWithMode :: ParseMode -> String -> ParseResult HsModule+> parseModuleWithMode :: ParseMode -> String -> ParseResult Module > parseModuleWithMode mode = runParserWithMode mode parse > }
Language/Haskell/Exts/Pretty.hs view
@@ -265,33 +265,33 @@ fullRender = fullRenderWithMode defaultMode ------------------------- Pretty-Print a Module ---------------------instance Pretty HsModule where- pretty (HsModule pos m mbExports imp decls) =+instance Pretty Module where+ pretty (Module pos m mbExports imp decls) = markLine pos $- topLevel (ppHsModuleHeader m mbExports)+ topLevel (ppModuleHeader m mbExports) (map pretty imp ++ map pretty decls) -------------------------- Module Header -------------------------------ppHsModuleHeader :: Module -> Maybe [HsExportSpec] -> Doc-ppHsModuleHeader m mbExportList = mySep [+ppModuleHeader :: ModuleName -> Maybe [ExportSpec] -> Doc+ppModuleHeader m mbExportList = mySep [ text "module", pretty m, maybePP (parenList . map pretty) mbExportList, text "where"] -instance Pretty Module where- pretty (Module modName) = text modName+instance Pretty ModuleName where+ pretty (ModuleName modName) = text modName -instance Pretty HsExportSpec where- pretty (HsEVar name) = pretty name- pretty (HsEAbs name) = pretty name- pretty (HsEThingAll name) = pretty name <> text "(..)"- pretty (HsEThingWith name nameList) =+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 (HsEModuleContents m) = text "module" <+> pretty m+ pretty (EModuleContents m) = text "module" <+> pretty m -instance Pretty HsImportDecl where- pretty (HsImportDecl pos m qual mbName mbSpecs) =+instance Pretty ImportDecl where+ pretty (ImportDecl pos m qual mbName mbSpecs) = markLine pos $ mySep [text "import", if qual then text "qualified" else empty,@@ -303,148 +303,140 @@ if b then text "hiding" <+> specs else specs where specs = parenList . map pretty $ specList -instance Pretty HsImportSpec where- pretty (HsIVar name) = pretty name- pretty (HsIAbs name) = pretty name- pretty (HsIThingAll name) = pretty name <> text "(..)"- pretty (HsIThingWith name nameList) =+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 HsDecl where- pretty (HsTypeDecl loc name nameList htype) =+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 (HsDataDecl loc don context name nameList constrList derives) =+ pretty (DataDecl loc don context name nameList constrList derives) = blankline $ markLine loc $- mySep ( [pretty don, ppHsContext context, pretty name]+ mySep ( [pretty don, ppContext context, pretty name] ++ map pretty nameList) <+> (myVcat (zipWith (<+>) (equals : repeat (char '|')) (map pretty constrList))- $$$ ppHsDeriving derives)+ $$$ ppDeriving derives) - pretty (HsGDataDecl loc don context name nameList optkind gadtList) =+ pretty (GDataDecl loc don context name nameList optkind gadtList) = blankline $ markLine loc $- mySep ( [pretty don, ppHsContext context, pretty name]+ mySep ( [pretty don, ppContext context, pretty name] ++ map pretty nameList ++ ppOptKind optkind ++ [text "where"]) $$$ ppBody classIndent (map pretty gadtList) - pretty (HsTypeFamDecl loc name nameList optkind) =+ pretty (TypeFamDecl loc name nameList optkind) = blankline $ markLine loc $ mySep ([text "type", text "family", pretty name] ++ map pretty nameList ++ ppOptKind optkind) - pretty (HsDataFamDecl loc context name nameList optkind) =+ pretty (DataFamDecl loc context name nameList optkind) = blankline $ markLine loc $- mySep ( [text "data", text "family", ppHsContext context, pretty name]+ mySep ( [text "data", text "family", ppContext context, pretty name] ++ map pretty nameList ++ ppOptKind optkind) - pretty (HsTypeInsDecl loc ntype htype) =+ pretty (TypeInsDecl loc ntype htype) = blankline $ markLine loc $ mySep [text "type", text "instance", pretty ntype, equals, pretty htype] - pretty (HsDataInsDecl loc don ntype constrList derives) =+ 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))- $$$ ppHsDeriving derives)+ $$$ ppDeriving derives) - pretty (HsGDataInsDecl loc don ntype optkind gadtList) =+ pretty (GDataInsDecl loc don ntype optkind gadtList) = blankline $ markLine loc $ mySep ( [pretty don, text "instance", pretty ntype] ++ ppOptKind optkind ++ [text "where"]) $$$ ppBody classIndent (map pretty gadtList) --{- pretty (HsNewTypeDecl pos context name nameList constr derives) =- blankline $- markLine pos $- mySep ( [text "newtype", ppHsContext context, pretty name]- ++ map pretty nameList)- <+> equals <+> (pretty constr $$$ ppHsDeriving derives)--} --m{spacing=False} -- special case for empty class declaration- pretty (HsClassDecl pos context name nameList fundeps []) =+ pretty (ClassDecl pos context name nameList fundeps []) = blankline $ markLine pos $- mySep ( [text "class", ppHsContext context, pretty name]+ mySep ( [text "class", ppContext context, pretty name] ++ map pretty nameList ++ [ppFunDeps fundeps])- pretty (HsClassDecl pos context name nameList fundeps declList) =+ pretty (ClassDecl pos context name nameList fundeps declList) = blankline $ markLine pos $- mySep ( [text "class", ppHsContext context, pretty name]+ 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 (HsInstDecl pos context name args []) =+ pretty (InstDecl pos context name args []) = blankline $ markLine pos $- mySep ( [text "instance", ppHsContext context, pretty name]- ++ map ppHsAType args)- pretty (HsInstDecl pos context name args declList) =+ mySep ( [text "instance", ppContext context, pretty name]+ ++ map ppAType args)+ pretty (InstDecl pos context name args declList) = blankline $ markLine pos $- mySep ( [text "instance", ppHsContext context, pretty name]- ++ map ppHsAType args ++ [text "where"])+ mySep ( [text "instance", ppContext context, pretty name]+ ++ map ppAType args ++ [text "where"]) $$$ ppBody classIndent (map pretty declList) - pretty (HsDerivDecl pos context name args) =+ pretty (DerivDecl pos context name args) = blankline $ markLine pos $- mySep ( [text "deriving", text "instance", ppHsContext context, pretty name]- ++ map ppHsAType args)- pretty (HsDefaultDecl pos htypes) =+ 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 (HsSpliceDecl pos splice) =+ pretty (SpliceDecl pos splice) = blankline $ markLine pos $ pretty splice - pretty (HsTypeSig pos nameList qualType) =+ pretty (TypeSig pos nameList qualType) = blankline $ markLine pos $ mySep ((punctuate comma . map pretty $ nameList) ++ [text "::", pretty qualType]) - pretty (HsFunBind matches) =+ pretty (FunBind matches) = foldr ($$$) empty (map pretty matches) - pretty (HsPatBind pos pat rhs whereBinds) =+ pretty (PatBind pos pat rhs whereBinds) = markLine pos $ myFsep [pretty pat, pretty rhs] $$$ ppWhere whereBinds - pretty (HsInfixDecl pos assoc prec opList) =+ pretty (InfixDecl pos assoc prec opList) = blankline $ markLine pos $ mySep ([pretty assoc, int prec] ++ (punctuate comma . map pretty $ opList)) - pretty (HsForImp pos cconv saf str name typ) =+ 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 (HsForExp pos cconv str name typ) =+ pretty (ForExp pos cconv str name typ) = blankline $ markLine pos $ mySep [text "foreign export", pretty cconv,@@ -454,62 +446,62 @@ pretty DataType = text "data" pretty NewType = text "newtype" -instance Pretty HsAssoc where- pretty HsAssocNone = text "infix"- pretty HsAssocLeft = text "infixl"- pretty HsAssocRight = text "infixr"+instance Pretty Assoc where+ pretty AssocNone = text "infix"+ pretty AssocLeft = text "infixl"+ pretty AssocRight = text "infixr" -instance Pretty HsMatch where- pretty (HsMatch pos f ps rhs whereBinds) =+instance Pretty Match where+ pretty (Match pos f ps rhs whereBinds) = markLine pos $ myFsep (lhs ++ [pretty rhs]) $$$ ppWhere whereBinds where lhs = case ps of l:r:ps' | isSymbolName f ->- let hd = [pretty l, ppHsName f, pretty r] in+ 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 :: HsBinds -> Doc-ppWhere (HsBDecls []) = empty-ppWhere (HsBDecls l) = nest 2 (text "where" $$$ ppBody whereIndent (map pretty l))-ppWhere (HsIPBinds b) = nest 2 (text "where" $$$ ppBody whereIndent (map pretty b))+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)) -instance Pretty HsClassDecl where- pretty (HsClsDecl decl) = pretty decl+instance Pretty ClassDecl where+ pretty (ClsDecl decl) = pretty decl - pretty (HsClsDataFam loc context name nameList optkind) =+ pretty (ClsDataFam loc context name nameList optkind) = markLine loc $- mySep ( [text "data", ppHsContext context, pretty name]+ mySep ( [text "data", ppContext context, pretty name] ++ map pretty nameList ++ ppOptKind optkind) - pretty (HsClsTyFam loc name nameList optkind) =+ pretty (ClsTyFam loc name nameList optkind) = markLine loc $ mySep ( [text "type", pretty name] ++ map pretty nameList ++ ppOptKind optkind) - pretty (HsClsTyDef loc ntype htype) =+ pretty (ClsTyDef loc ntype htype) = markLine loc $ mySep [text "type", pretty ntype, equals, pretty htype] -instance Pretty HsInstDecl where- pretty (HsInsDecl decl) = pretty decl+instance Pretty InstDecl where+ pretty (InsDecl decl) = pretty decl - pretty (HsInsType loc ntype htype) =+ pretty (InsType loc ntype htype) = markLine loc $ mySep [text "type", pretty ntype, equals, pretty htype] - pretty (HsInsData loc don ntype constrList derives) =+ pretty (InsData loc don ntype constrList derives) = markLine loc $ mySep [pretty don, pretty ntype] <+> (myVcat (zipWith (<+>) (equals : repeat (char '|')) (map pretty constrList))- $$$ ppHsDeriving derives)+ $$$ ppDeriving derives) - pretty (HsInsGData loc don ntype optkind gadtList) =+ pretty (InsGData loc don ntype optkind gadtList) = markLine loc $ mySep ( [pretty don, pretty ntype] ++ ppOptKind optkind ++ [text "where"])@@ -517,58 +509,53 @@ ------------------------- FFI stuff --------------------------------------instance Pretty HsSafety where+instance Pretty Safety where pretty PlayRisky = text "unsafe" pretty (PlaySafe b) = text $ if b then "threadsafe" else "safe" -instance Pretty HsCallConv where+instance Pretty CallConv where pretty StdCall = text "stdcall" pretty CCall = text "ccall" ------------------------- Data & Newtype Bodies --------------------------instance Pretty HsQualConDecl where- pretty (HsQualConDecl _pos tvs ctxt con) =- myFsep [ppForall (Just tvs), ppHsContext ctxt, pretty con]+instance Pretty QualConDecl where+ pretty (QualConDecl _pos tvs ctxt con) =+ myFsep [ppForall (Just tvs), ppContext ctxt, pretty con] -instance Pretty HsGadtDecl where- pretty (HsGadtDecl _pos name ty) =+instance Pretty GadtDecl where+ pretty (GadtDecl _pos name ty) = myFsep [pretty name, text "::", pretty ty] -instance Pretty HsConDecl where- pretty (HsRecDecl name fieldList) =+instance Pretty ConDecl where+ pretty (RecDecl name fieldList) = pretty name <> (braceList . map ppField $ fieldList) - pretty (HsConDecl name@(HsSymbol _) [l, r]) =- myFsep [prettyPrec prec_btype l, ppHsName name,+ pretty (ConDecl name@(Symbol _) [l, r]) =+ myFsep [prettyPrec prec_btype l, ppName name, prettyPrec prec_btype r]- pretty (HsConDecl name typeList) =- mySep $ ppHsName name : map (prettyPrec prec_atype) typeList+ pretty (ConDecl name typeList) =+ mySep $ ppName name : map (prettyPrec prec_atype) typeList -ppField :: ([HsName],HsBangType) -> Doc+ppField :: ([Name],BangType) -> Doc ppField (names, ty) = myFsepSimple $ (punctuate comma . map pretty $ names) ++ [text "::", pretty ty] -instance Pretty HsBangType where- prettyPrec _ (HsBangedTy ty) = char '!' <> ppHsAType ty- prettyPrec p (HsUnBangedTy ty) = prettyPrec p ty+instance Pretty BangType where+ prettyPrec _ (BangedTy ty) = char '!' <> ppAType ty+ prettyPrec p (UnBangedTy ty) = prettyPrec p ty -ppHsDeriving :: [HsQName] -> Doc-ppHsDeriving [] = empty-ppHsDeriving [d] = text "deriving" <+> ppHsQName d-ppHsDeriving ds = text "deriving" <+> parenList (map ppHsQName ds)+ppDeriving :: [QName] -> Doc+ppDeriving [] = empty+ppDeriving [d] = text "deriving" <+> ppQName d+ppDeriving ds = text "deriving" <+> parenList (map ppQName ds) ------------------------- Types --------------------------{--instance Pretty HsQualType where- pretty (HsQualType context htype) =- myFsep [ppHsContext context, pretty htype]--}-ppHsBType :: HsType -> Doc-ppHsBType = prettyPrec prec_btype+ppBType :: Type -> Doc+ppBType = prettyPrec prec_btype -ppHsAType :: HsType -> Doc-ppHsAType = prettyPrec prec_atype+ppAType :: Type -> Doc+ppAType = prettyPrec prec_atype -- precedences for types prec_btype, prec_atype :: Int@@ -576,189 +563,184 @@ -- or either argument of an infix data constructor prec_atype = 2 -- argument of type or data constructor, or of a class -instance Pretty HsType where- prettyPrec p (HsTyForall mtvs ctxt htype) = parensIf (p > 0) $- myFsep [ppForall mtvs, ppHsContext ctxt, pretty htype]- prettyPrec p (HsTyFun a b) = parensIf (p > 0) $- myFsep [ppHsBType a, text "->", pretty b]- prettyPrec _ (HsTyTuple bxd l) =+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 (HsTyApp a b)+ prettyPrec p (TyApp a b) | a == list_tycon = brackets $ pretty b -- special case | otherwise = parensIf (p > prec_btype) $- myFsep [pretty a, ppHsAType b]- prettyPrec _ (HsTyVar name) = pretty name- prettyPrec _ (HsTyCon name) = pretty name- prettyPrec _ (HsTyPred asst) = pretty asst- prettyPrec _ (HsTyInfix a op b) = parens (myFsep [pretty op, pretty a, pretty b])- prettyPrec _ (HsTyKind t k) = parens (myFsep [pretty t, text "::", pretty k])+ 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 HsTyVarBind where- pretty (HsKindedVar var kind) = myFsep [pretty var, text "::", pretty kind]- pretty (HsUnkindedVar var) = pretty var+instance Pretty TyVarBind where+ pretty (KindedVar var kind) = myFsep [pretty var, text "::", pretty kind]+ pretty (UnkindedVar var) = pretty var -ppForall :: Maybe [HsTyVarBind] -> Doc+ppForall :: Maybe [TyVarBind] -> Doc ppForall Nothing = empty ppForall (Just []) = empty ppForall (Just vs) = myFsep (text "forall" : map pretty vs ++ [char '.']) ---------------------------- Kinds ---------------------------- -instance Pretty HsKind where- pretty HsKindStar = text "*"- pretty HsKindBang = text "!"- pretty (HsKindFn a b) = myFsep [pretty a, text "->", pretty b]+instance Pretty Kind where+ pretty KindStar = text "*"+ pretty KindBang = text "!"+ pretty (KindFn a b) = myFsep [pretty a, text "->", pretty b] -ppOptKind :: Maybe HsKind -> [Doc]+ppOptKind :: Maybe Kind -> [Doc] ppOptKind Nothing = [] ppOptKind (Just k) = [text "::", pretty k] ------------------- Functional Dependencies --------------------instance Pretty HsFunDep where- pretty (HsFunDep from to) =+instance Pretty FunDep where+ pretty (FunDep from to) = myFsep $ map pretty from ++ [text "->"] ++ map pretty to -ppFunDeps :: [HsFunDep] -> Doc+ppFunDeps :: [FunDep] -> Doc ppFunDeps [] = empty ppFunDeps fds = myFsep $ (char '|':) . punctuate comma . map pretty $ fds ------------------------- Expressions --------------------------instance Pretty HsRhs where- pretty (HsUnGuardedRhs e) = equals <+> pretty e- pretty (HsGuardedRhss guardList) = myVcat . map pretty $ guardList+instance Pretty Rhs where+ pretty (UnGuardedRhs e) = equals <+> pretty e+ pretty (GuardedRhss guardList) = myVcat . map pretty $ guardList -instance Pretty HsGuardedRhs where- pretty (HsGuardedRhs _pos guards ppBody) =+instance Pretty GuardedRhs where+ pretty (GuardedRhs _pos guards ppBody) = myFsep $ [char '|'] ++ (punctuate comma . map pretty $ guards) ++ [equals, pretty ppBody] -instance Pretty HsLiteral where- pretty (HsInt i) = integer i- pretty (HsChar c) = text (show c)- pretty (HsString s) = text (show s)- pretty (HsFrac r) = double (fromRational r)+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 (HsCharPrim c) = text (show c) <> char '#'- pretty (HsStringPrim s) = text (show s) <> char '#'- pretty (HsIntPrim i) = integer i <> char '#'- pretty (HsFloatPrim r) = float (fromRational r) <> char '#'- pretty (HsDoublePrim r) = double (fromRational r) <> text "##"+ pretty (CharPrim c) = text (show c) <> char '#'+ pretty (StringPrim s) = text (show s) <> char '#'+ pretty (IntPrim i) = integer i <> char '#'+ pretty (FloatPrim r) = float (fromRational r) <> char '#'+ pretty (DoublePrim r) = double (fromRational r) <> text "##" -instance Pretty HsExp where- pretty (HsLit l) = pretty l+instance Pretty Exp where+ pretty (Lit l) = pretty l -- lambda stuff- pretty (HsInfixApp a op b) = myFsep [pretty a, pretty op, pretty b]- pretty (HsNegApp e) = myFsep [char '-', pretty e]- pretty (HsApp a b) = myFsep [pretty a, pretty b]- pretty (HsLambda _loc expList ppBody) = myFsep $+ 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 (HsLet (HsBDecls declList) letBody) =+ pretty (Let (BDecls declList) letBody) = ppLetExp declList letBody- pretty (HsLet (HsIPBinds bindList) letBody) =+ pretty (Let (IPBinds bindList) letBody) = ppLetExp bindList letBody -{- No longer supported.- pretty (HsDLet bindList letBody) =- myFsep [text "dlet" <+> ppBody letIndent (map pretty bindList),- text "in", pretty letBody]- pretty (HsWith exp bindList) =- pretty exp $$$ ppWith bindList --}- pretty (HsIf cond thenexp elsexp) =+ pretty (If cond thenexp elsexp) = myFsep [text "if", pretty cond, text "then", pretty thenexp, text "else", pretty elsexp]- pretty (HsCase cond altList) =+ pretty (Case cond altList) = myFsep [text "case", pretty cond, text "of"] $$$ ppBody caseIndent (map pretty altList)- pretty (HsDo stmtList) =+ pretty (Do stmtList) = text "do" $$$ ppBody doIndent (map pretty stmtList)- pretty (HsMDo stmtList) =+ pretty (MDo stmtList) = text "mdo" $$$ ppBody doIndent (map pretty stmtList) -- Constructors & Vars- pretty (HsVar name) = pretty name- pretty (HsIPVar ipname) = pretty ipname- pretty (HsCon name) = pretty name- pretty (HsTuple expList) = parenList . map pretty $ expList+ 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 (HsParen e) = parens . pretty $ e- pretty (HsLeftSection e op) = parens (pretty e <+> pretty op)- pretty (HsRightSection op e) = parens (pretty op <+> pretty e)- pretty (HsRecConstr c fieldList) =+ pretty (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 (HsRecUpdate e fieldList) =+ pretty (RecUpdate e fieldList) = pretty e <> (braceList . map pretty $ fieldList) -- patterns -- special case that would otherwise be buggy- pretty (HsAsPat name (HsIrrPat e)) =+{- pretty (AsPat name (IrrPat e)) = myFsep [pretty name <> char '@', char '~' <> pretty e]- pretty (HsAsPat name e) = hcat [pretty name, char '@', pretty e]- pretty HsWildCard = char '_'- pretty (HsIrrPat e) = char '~' <> pretty e+ pretty (AsPat name e) = hcat [pretty name, char '@', pretty e]+ pretty WildCard = char '_'+ pretty (IrrPat e) = char '~' <> pretty e+-} -- Lists- pretty (HsList list) =+ pretty (List list) = bracketList . punctuate comma . map pretty $ list- pretty (HsEnumFrom e) =+ pretty (EnumFrom e) = bracketList [pretty e, text ".."]- pretty (HsEnumFromTo from to) =+ pretty (EnumFromTo from to) = bracketList [pretty from, text "..", pretty to]- pretty (HsEnumFromThen from thenE) =+ pretty (EnumFromThen from thenE) = bracketList [pretty from <> comma, pretty thenE, text ".."]- pretty (HsEnumFromThenTo from thenE to) =+ pretty (EnumFromThenTo from thenE to) = bracketList [pretty from <> comma, pretty thenE, text "..", pretty to]- pretty (HsListComp e stmtList) =+ pretty (ListComp e stmtList) = bracketList ([pretty e, char '|'] ++ (punctuate comma . map pretty $ stmtList))- pretty (HsExpTypeSig _pos e ty) =+ pretty (ExpTypeSig _pos e ty) = myFsep [pretty e, text "::", pretty ty] -- Template Haskell--- pretty (HsReifyExp r) = pretty r- pretty (HsBracketExp b) = pretty b- pretty (HsSpliceExp s) = pretty s- pretty (HsTypQuote t) = text "\'\'" <> pretty t- pretty (HsVarQuote x) = text "\'" <> pretty x- -- regular patterns- pretty (HsSeqRP rs) =+ pretty (BracketExp b) = pretty b+ pretty (SpliceExp s) = pretty s+ pretty (TypQuote t) = text "\'\'" <> pretty t+ pretty (VarQuote x) = text "\'" <> pretty x+{- -- regular patterns+ pretty (SeqRP rs) = myFsep $ text "(/" : map pretty rs ++ [text "/)"]- pretty (HsEitherRP r1 r2) = parens . myFsep $+ pretty (EitherRP r1 r2) = parens . myFsep $ [pretty r1, char '|', pretty r2]- pretty (HsGuardRP r gs) = + pretty (GuardRP r gs) = myFsep $ text "(|" : pretty r : char '|' : map pretty gs ++ [text "|)"] -- special case that would otherwise be buggy- pretty (HsCAsRP n (HsIrrPat e)) =+ pretty (CAsRP n (IrrPat e)) = myFsep [pretty n <> text "@:", char '~' <> pretty e]- pretty (HsCAsRP n r) = hcat [pretty n, text "@:", pretty r]+ pretty (CAsRP n r) = hcat [pretty n, text "@:", pretty r]+-} -- Hsx- pretty (HsXTag _ n attrs mattr cs) =+ 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 (HsXETag _ n attrs mattr) =+ pretty (XETag _ n attrs mattr) = let ax = maybe [] (return . pretty) mattr in myFsep $ (char '<' <> pretty n): map pretty attrs ++ ax ++ [text "/>"]- pretty (HsXPcdata s) = text s- pretty (HsXExpTag e) =+ pretty (XPcdata s) = text s+ pretty (XExpTag e) = myFsep $ [text "<%", pretty e, text "%>"]- pretty (HsXRPats es) =+{- pretty (XRPats es) = myFsep $ text "<[" : map pretty es ++ [text "]>"]+-} -instance Pretty HsXAttr where- pretty (HsXAttr n v) =+instance Pretty XAttr where+ pretty (XAttr n v) = myFsep [pretty n, char '=', pretty v] -instance Pretty HsXName where- pretty (HsXName n) = text n- pretty (HsXDomName d n) = text d <> char ':' <> text n+instance Pretty XName where+ pretty (XName n) = text n+ pretty (XDomName d n) = text d <> char ':' <> text n ---ppLetExp :: [HsDecl] -> HsExp -> Doc+--ppLetExp :: [Decl] -> Exp -> Doc ppLetExp l b = myFsep [text "let" <+> ppBody letIndent (map pretty l), text "in", pretty b] @@ -766,235 +748,210 @@ withIndent = whereIndent --------------------- Template Haskell --------------------------{--instance Pretty HsReify where- pretty (HsReifyDecl name) = ppReify "reifyDecl" name- pretty (HsReifyType name) = ppReify "reifyType" name- pretty (HsReifyFixity name) = ppReify "reifyFixity" name -ppReify t n = myFsep [text t, pretty n]---}--instance Pretty HsBracket where- pretty (HsExpBracket e) = ppBracket "[|" e- pretty (HsPatBracket p) = ppBracket "[p|" p- pretty (HsTypeBracket t) = ppBracket "[t|" t- pretty (HsDeclBracket d) =+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 HsSplice where- pretty (HsIdSplice s) = char '$' <> text s- pretty (HsParenSplice e) =+instance Pretty Splice where+ pretty (IdSplice s) = char '$' <> text s+ pretty (ParenSplice e) = myFsep [text "$(", pretty e, char ')'] ------------------------- Patterns ----------------------------- -instance Pretty HsPat where- prettyPrec _ (HsPVar name) = pretty name- prettyPrec _ (HsPLit lit) = pretty lit- prettyPrec _ (HsPNeg p) = myFsep [char '-', pretty p]- prettyPrec p (HsPInfixApp a op b) = parensIf (p > 0) $- myFsep [pretty a, pretty (HsQConOp op), pretty b]- prettyPrec p (HsPApp n ps) = parensIf (p > 1) $+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 _ (HsPTuple ps) = parenList . map pretty $ ps- prettyPrec _ (HsPList ps) =+ prettyPrec _ (PTuple ps) = parenList . map pretty $ ps+ prettyPrec _ (PList ps) = bracketList . punctuate comma . map pretty $ ps- prettyPrec _ (HsPParen p) = parens . pretty $ p- prettyPrec _ (HsPRec c fields) =+ prettyPrec _ (PParen p) = parens . pretty $ p+ prettyPrec _ (PRec c fields) = pretty c <> (braceList . map pretty $ fields) -- special case that would otherwise be buggy- prettyPrec _ (HsPAsPat name (HsPIrrPat pat)) =+ prettyPrec _ (PAsPat name (PIrrPat pat)) = myFsep [pretty name <> char '@', char '~' <> pretty pat]- prettyPrec _ (HsPAsPat name pat) =+ prettyPrec _ (PAsPat name pat) = hcat [pretty name, char '@', pretty pat]- prettyPrec _ HsPWildCard = char '_'- prettyPrec _ (HsPIrrPat pat) = char '~' <> pretty pat- prettyPrec _ (HsPatTypeSig _pos pat ty) =+ prettyPrec _ PWildCard = char '_'+ prettyPrec _ (PIrrPat pat) = char '~' <> pretty pat+ prettyPrec _ (PatTypeSig _pos pat ty) = myFsep [pretty pat, text "::", pretty ty] -- HaRP- prettyPrec _ (HsPRPat rs) = + prettyPrec _ (PRPat rs) = bracketList . punctuate comma . map pretty $ rs -- Hsx- prettyPrec _ (HsPXTag _ n attrs mattr cp) =+ 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 _ (HsPXETag _ n attrs mattr) =+ prettyPrec _ (PXETag _ n attrs mattr) = let ap = maybe [] (return . pretty) mattr in myFsep $ (char '<' <> pretty n): map pretty attrs ++ ap ++ [text "/>"]- prettyPrec _ (HsPXPcdata s) = text s- prettyPrec _ (HsPXPatTag p) =+ prettyPrec _ (PXPcdata s) = text s+ prettyPrec _ (PXPatTag p) = myFsep $ [text "<%", pretty p, text "%>"]- prettyPrec _ (HsPXRPats ps) =+ prettyPrec _ (PXRPats ps) = myFsep $ text "<[" : map pretty ps ++ [text "%>"] -{--prettyChildren :: HsPat -> [Doc]-prettyChildren p = case p of- HsPList ps -> map prettyChild ps- HsPRPat _ _ -> [pretty p]- _ -> error "The pattern representing the children of an xml pattern \- \ should always be a list."--prettyChild :: HsPat -> Doc-prettyChild p = case p of- HsPXTag _ _ _ _ _ -> pretty p- HsPXETag _ _ _ _ -> pretty p- HsPXPatTag _ -> pretty p- HsPXPcdata _ -> pretty p- _ -> pretty $ HsPXPatTag p--}--instance Pretty HsPXAttr where- pretty (HsPXAttr n p) =+instance Pretty PXAttr where+ pretty (PXAttr n p) = myFsep [pretty n, char '=', pretty p] -instance Pretty HsPatField where- pretty (HsPFieldPat name pat) =+instance Pretty PatField where+ pretty (PFieldPat name pat) = myFsep [pretty name, equals, pretty pat] --------------------- Regular Patterns ------------------------- -instance Pretty HsRPat where- pretty (HsRPOp r op) = pretty r <> pretty op- pretty (HsRPEither r1 r2) = parens . myFsep $+instance Pretty RPat where+ pretty (RPOp r op) = pretty r <> pretty op+ pretty (RPEither r1 r2) = parens . myFsep $ [pretty r1, char '|', pretty r2]- pretty (HsRPSeq rs) =+ pretty (RPSeq rs) = myFsep $ text "(/" : map pretty rs ++ [text "/)"]- pretty (HsRPGuard r gs) =+ pretty (RPGuard r gs) = myFsep $ text "(|" : pretty r : char '|' : map pretty gs ++ [text "|)"] -- special case that would otherwise be buggy- pretty (HsRPCAs n (HsRPPat (HsPIrrPat p))) =+ pretty (RPCAs n (RPPat (PIrrPat p))) = myFsep [pretty n <> text "@:", char '~' <> pretty p]- pretty (HsRPCAs n r) = hcat [pretty n, text "@:", pretty r]+ pretty (RPCAs n r) = hcat [pretty n, text "@:", pretty r] -- special case that would otherwise be buggy- pretty (HsRPAs n (HsRPPat (HsPIrrPat p))) =+ pretty (RPAs n (RPPat (PIrrPat p))) = myFsep [pretty n <> text "@:", char '~' <> pretty p]- pretty (HsRPAs n r) = hcat [pretty n, char '@', pretty r]- pretty (HsRPPat p) = pretty p- pretty (HsRPParen rp) = parens . pretty $ rp+ pretty (RPAs n r) = hcat [pretty n, char '@', pretty r]+ pretty (RPPat p) = pretty p+ pretty (RPParen rp) = parens . pretty $ rp -instance Pretty HsRPatOp where- pretty HsRPStar = char '*'- pretty HsRPStarG = text "*!"- pretty HsRPPlus = char '+'- pretty HsRPPlusG = text "+!"- pretty HsRPOpt = char '?'- pretty HsRPOptG = text "?!"+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 HsAlt where- pretty (HsAlt _pos e gAlts binds) =+instance Pretty Alt where+ pretty (Alt _pos e gAlts binds) = pretty e <+> pretty gAlts $$$ ppWhere binds -instance Pretty HsGuardedAlts where- pretty (HsUnGuardedAlt e) = text "->" <+> pretty e- pretty (HsGuardedAlts altList) = myVcat . map pretty $ altList+instance Pretty GuardedAlts where+ pretty (UnGuardedAlt e) = text "->" <+> pretty e+ pretty (GuardedAlts altList) = myVcat . map pretty $ altList -instance Pretty HsGuardedAlt where- pretty (HsGuardedAlt _pos guards body) =+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 HsStmt where- pretty (HsGenerator _loc e from) =+instance Pretty Stmt where+ pretty (Generator _loc e from) = pretty e <+> text "<-" <+> pretty from- pretty (HsQualifier e) = pretty e+ pretty (Qualifier e) = pretty e -- two cases for lets- pretty (HsLetStmt (HsBDecls declList)) =+ pretty (LetStmt (BDecls declList)) = ppLetStmt declList- pretty (HsLetStmt (HsIPBinds bindList)) =+ pretty (LetStmt (IPBinds bindList)) = ppLetStmt bindList ppLetStmt l = text "let" $$$ ppBody letIndent (map pretty l) ------------------------- Record updates-instance Pretty HsFieldUpdate where- pretty (HsFieldUpdate name e) =+instance Pretty FieldUpdate where+ pretty (FieldUpdate name e) = myFsep [pretty name, equals, pretty e] ------------------------- Names --------------------------instance Pretty HsQOp where- pretty (HsQVarOp n) = ppHsQNameInfix n- pretty (HsQConOp n) = ppHsQNameInfix n+instance Pretty QOp where+ pretty (QVarOp n) = ppQNameInfix n+ pretty (QConOp n) = ppQNameInfix n -ppHsQNameInfix :: HsQName -> Doc-ppHsQNameInfix name- | isSymbolName (getName name) = ppHsQName name- | otherwise = char '`' <> ppHsQName name <> char '`'+ppQNameInfix :: QName -> Doc+ppQNameInfix name+ | isSymbolName (getName name) = ppQName name+ | otherwise = char '`' <> ppQName name <> char '`' -instance Pretty HsQName where+instance Pretty QName where pretty name = case name of- UnQual (HsSymbol ('#':_)) -> char '(' <+> ppHsQName name <+> char ')'- _ -> parensIf (isSymbolName (getName name)) (ppHsQName name)+ UnQual (Symbol ('#':_)) -> char '(' <+> ppQName name <+> char ')'+ _ -> parensIf (isSymbolName (getName name)) (ppQName name) -ppHsQName :: HsQName -> Doc-ppHsQName (UnQual name) = ppHsName name-ppHsQName (Qual m name) = pretty m <> char '.' <> ppHsName name-ppHsQName (Special sym) = text (specialName sym)+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 HsOp where- pretty (HsVarOp n) = ppHsNameInfix n- pretty (HsConOp n) = ppHsNameInfix n+instance Pretty Op where+ pretty (VarOp n) = ppNameInfix n+ pretty (ConOp n) = ppNameInfix n -ppHsNameInfix :: HsName -> Doc-ppHsNameInfix name- | isSymbolName name = ppHsName name- | otherwise = char '`' <> ppHsName name <> char '`'+ppNameInfix :: Name -> Doc+ppNameInfix name+ | isSymbolName name = ppName name+ | otherwise = char '`' <> ppName name <> char '`' -instance Pretty HsName where+instance Pretty Name where pretty name = case name of- HsSymbol ('#':_) -> char '(' <+> ppHsName name <+> char ')'- _ -> parensIf (isSymbolName name) (ppHsName name)+ Symbol ('#':_) -> char '(' <+> ppName name <+> char ')'+ _ -> parensIf (isSymbolName name) (ppName name) -ppHsName :: HsName -> Doc-ppHsName (HsIdent s) = text s-ppHsName (HsSymbol s) = text s+ppName :: Name -> Doc+ppName (Ident s) = text s+ppName (Symbol s) = text s -instance Pretty HsIPName where- pretty (HsIPDup s) = char '?' <> text s- pretty (HsIPLin s) = char '%' <> text s+instance Pretty IPName where+ pretty (IPDup s) = char '?' <> text s+ pretty (IPLin s) = char '%' <> text s -instance Pretty HsIPBind where- pretty (HsIPBind _loc ipname exp) =+instance Pretty IPBind where+ pretty (IPBind _loc ipname exp) = myFsep [pretty ipname, equals, pretty exp] -instance Pretty HsCName where- pretty (HsVarName n) = pretty n- pretty (HsConName n) = pretty n+instance Pretty CName where+ pretty (VarName n) = pretty n+ pretty (ConName n) = pretty n -isSymbolName :: HsName -> Bool-isSymbolName (HsSymbol _) = True+isSymbolName :: Name -> Bool+isSymbolName (Symbol _) = True isSymbolName _ = False -getName :: HsQName -> HsName+getName :: QName -> Name getName (UnQual s) = s getName (Qual _ s) = s-getName (Special HsCons) = HsSymbol ":"-getName (Special HsFunCon) = HsSymbol "->"-getName (Special s) = HsIdent (specialName s)+getName (Special Cons) = Symbol ":"+getName (Special FunCon) = Symbol "->"+getName (Special s) = Ident (specialName s) -specialName :: HsSpecialCon -> String-specialName HsUnitCon = "()"-specialName HsListCon = "[]"-specialName HsFunCon = "->"-specialName (HsTupleCon n) = "(" ++ replicate (n-1) ',' ++ ")"-specialName HsCons = ":"+specialName :: SpecialCon -> String+specialName UnitCon = "()"+specialName ListCon = "[]"+specialName FunCon = "->"+specialName (TupleCon n) = "(" ++ replicate (n-1) ',' ++ ")"+specialName Cons = ":" -ppHsContext :: HsContext -> Doc-ppHsContext [] = empty-ppHsContext context = mySep [parenList (map pretty context), text "=>"]+ppContext :: Context -> Doc+ppContext [] = empty+ppContext context = mySep [parenList (map pretty context), text "=>"] -- hacked for multi-parameter type classes-instance Pretty HsAsst where- pretty (HsClassA a ts) = myFsep $ ppHsQName a : map ppHsAType ts- pretty (HsIParam i t) = myFsep $ [pretty i, text "::", pretty t]- pretty (HsEqualP t1 t2) = myFsep $ [pretty t1, text "~", pretty t2]+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
Language/Haskell/Exts/Syntax.hs view
@@ -41,40 +41,40 @@ module Language.Haskell.Exts.Syntax ( -- * Modules- HsModule(..), HsExportSpec(..),- HsImportDecl(..), HsImportSpec(..), HsAssoc(..),+ Module(..), ExportSpec(..),+ ImportDecl(..), ImportSpec(..), Assoc(..), -- * Declarations- HsDecl(..), HsBinds(..), HsIPBind(..), - HsClassDecl(..), HsInstDecl(..),- HsGadtDecl(..), HsConDecl(..), HsQualConDecl(..), HsBangType(..),- HsMatch(..), HsRhs(..), HsGuardedRhs(..), DataOrNew(..),+ Decl(..), Binds(..), IPBind(..), + ClassDecl(..), InstDecl(..),+ GadtDecl(..), ConDecl(..), QualConDecl(..), BangType(..),+ Match(..), Rhs(..), GuardedRhs(..), DataOrNew(..), -- * Class Assertions and Contexts- HsContext, HsFunDep(..), HsAsst(..),+ Context, FunDep(..), Asst(..), -- * Types- HsType(..), HsBoxed(..), HsKind(..), HsTyVarBind(..),+ Type(..), Boxed(..), Kind(..), TyVarBind(..), -- * Expressions- HsExp(..), HsStmt(..), HsFieldUpdate(..),- HsAlt(..), HsGuardedAlts(..), HsGuardedAlt(..), + Exp(..), Stmt(..), FieldUpdate(..),+ Alt(..), GuardedAlts(..), GuardedAlt(..), -- * Patterns- HsPat(..), HsPatField(..),+ Pat(..), PatField(..), -- * Literals- HsLiteral(..),+ Literal(..), -- * Variables, Constructors and Operators- Module(..), HsQName(..), HsName(..), HsQOp(..), HsOp(..),- HsSpecialCon(..), HsCName(..), HsIPName(..),+ ModuleName(..), QName(..), Name(..), QOp(..), Op(..),+ SpecialCon(..), CName(..), IPName(..), -- * Template Haskell -- HsReify(..), - HsBracket(..), HsSplice(..),+ Bracket(..), Splice(..), -- * HaRP- HsRPat(..), HsRPatOp(..),+ RPat(..), RPatOp(..), -- * Hsx- HsXAttr(..), HsXName(..), HsPXAttr(..),+ XAttr(..), XName(..), PXAttr(..), -- * FFI- HsSafety(..), HsCallConv(..),+ Safety(..), CallConv(..), -- * Builtin names @@ -114,7 +114,7 @@ #endif -- | The name of a Haskell module.-newtype Module = Module String+newtype ModuleName = ModuleName String #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else@@ -125,13 +125,13 @@ -- These names are never qualified, and always refer to builtin type or -- data constructors. -data HsSpecialCon- = HsUnitCon -- ^ unit type and data constructor @()@- | HsListCon -- ^ list type constructor @[]@- | HsFunCon -- ^ function type constructor @->@- | HsTupleCon Int -- ^ /n/-ary tuple type and data+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- | HsCons -- ^ list data constructor @(:)@+ | Cons -- ^ list data constructor @(:)@ #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else@@ -140,10 +140,10 @@ -- | This type is used to represent qualified variables, and also -- qualified constructors.-data HsQName- = Qual Module HsName -- ^ name qualified with a module name- | UnQual HsName -- ^ unqualified name- | Special HsSpecialCon -- ^ built-in constructor with special syntax+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@@ -151,9 +151,9 @@ #endif -- | This type is used to represent variables, and also constructors.-data HsName- = HsIdent String -- ^ /varid/ or /conid/.- | HsSymbol String -- ^ /varsym/ or /consym/+data Name+ = Ident String -- ^ /varid/ or /conid/.+ | Symbol String -- ^ /varsym/ or /consym/ #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else@@ -161,9 +161,9 @@ #endif -- | This type is used to represent implicit parameter names.-data HsIPName- = HsIPDup String -- ?x- | HsIPLin String -- %x+data IPName+ = IPDup String -- ?x+ | IPLin String -- %x #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else@@ -171,9 +171,9 @@ #endif -- | Possibly qualified infix operators (/qop/), appearing in expressions.-data HsQOp- = HsQVarOp HsQName -- ^ variable operator (/qvarop/)- | HsQConOp HsQName -- ^ constructor operator (/qconop/)+data QOp+ = QVarOp QName -- ^ variable operator (/qvarop/)+ | QConOp QName -- ^ constructor operator (/qconop/) #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else@@ -181,9 +181,9 @@ #endif -- | Operators, appearing in @infix@ declarations.-data HsOp- = HsVarOp HsName -- ^ variable operator (/varop/)- | HsConOp HsName -- ^ constructor operator (/conop/)+data Op+ = VarOp Name -- ^ variable operator (/varop/)+ | ConOp Name -- ^ constructor operator (/conop/) #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else@@ -192,9 +192,9 @@ -- | A name (/cname/) of a component of a class or data type in an @import@ -- or export specification.-data HsCName- = HsVarName HsName -- ^ name of a method or field- | HsConName HsName -- ^ name of a data constructor+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@@ -202,8 +202,8 @@ #endif -- | A Haskell source module.-data HsModule = HsModule SrcLoc Module (Maybe [HsExportSpec])- [HsImportDecl] [HsDecl]+data Module = Module SrcLoc ModuleName (Maybe [ExportSpec])+ [ImportDecl] [Decl] #ifdef __GLASGOW_HASKELL__ deriving (Show,Typeable,Data) #else@@ -211,18 +211,18 @@ #endif -- | Export specification.-data HsExportSpec- = HsEVar HsQName -- ^ variable- | HsEAbs HsQName -- ^ @T@:+data ExportSpec+ = EVar QName -- ^ variable+ | EAbs QName -- ^ @T@: -- a class or datatype exported abstractly, -- or a type synonym.- | HsEThingAll HsQName -- ^ @T(..)@:+ | EThingAll QName -- ^ @T(..)@: -- a class exported with all of its methods, or -- a datatype exported with all of its constructors.- | HsEThingWith HsQName [HsCName] -- ^ @T(C_1,...,C_n)@:+ | 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.- | HsEModuleContents Module -- ^ @module M@:+ | EModuleContents ModuleName -- ^ @module M@: -- re-export a module. #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data)@@ -231,13 +231,13 @@ #endif -- | Import declaration.-data HsImportDecl = HsImportDecl- { importLoc :: SrcLoc -- ^ position of the @import@ keyword.- , importModule :: Module -- ^ name of the module imported.- , importQualified :: Bool -- ^ imported @qualified@?- , importAs :: Maybe Module -- ^ optional alias name in an+data ImportDecl = ImportDecl+ { importLoc :: SrcLoc -- ^ position of the @import@ keyword.+ , importModule :: ModuleName -- ^ name of the module imported.+ , importQualified :: Bool -- ^ imported @qualified@?+ , importAs :: Maybe ModuleName -- ^ optional alias name in an -- @as@ clause.- , importSpecs :: Maybe (Bool,[HsImportSpec])+ , importSpecs :: Maybe (Bool,[ImportSpec]) -- ^ optional list of import specifications. -- The 'Bool' is 'True' if the names are excluded -- by @hiding@.@@ -249,14 +249,14 @@ #endif -- | Import specification.-data HsImportSpec- = HsIVar HsName -- ^ variable- | HsIAbs HsName -- ^ @T@:+data ImportSpec+ = IVar Name -- ^ variable+ | IAbs Name -- ^ @T@: -- the name of a class, datatype or type synonym.- | HsIThingAll HsName -- ^ @T(..)@:+ | IThingAll Name -- ^ @T(..)@: -- a class imported with all of its methods, or -- a datatype imported with all of its constructors.- | HsIThingWith HsName [HsCName] -- ^ @T(C_1,...,C_n)@:+ | 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__@@ -266,36 +266,36 @@ #endif -- | Associativity of an operator.-data HsAssoc- = HsAssocNone -- ^ non-associative operator (declared with @infix@)- | HsAssocLeft -- ^ left-associative operator (declared with @infixl@).- | HsAssocRight -- ^ right-associative operator (declared with @infixr@)+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 -data HsDecl- = HsTypeDecl SrcLoc HsName [HsName] HsType- | HsDataDecl SrcLoc DataOrNew HsContext HsName [HsName] [HsQualConDecl] [HsQName]- | HsGDataDecl SrcLoc DataOrNew HsContext HsName [HsName] (Maybe HsKind) [HsGadtDecl] {-no deriving-}- | HsTypeFamDecl SrcLoc HsName [HsName] (Maybe HsKind)- | HsDataFamDecl SrcLoc HsContext HsName [HsName] (Maybe HsKind)- | HsTypeInsDecl SrcLoc HsType HsType- | HsDataInsDecl SrcLoc DataOrNew HsType [HsQualConDecl] [HsQName]- | HsGDataInsDecl SrcLoc DataOrNew HsType (Maybe HsKind) [HsGadtDecl] {-no deriving-}- | HsInfixDecl SrcLoc HsAssoc Int [HsOp]- | HsClassDecl SrcLoc HsContext HsName [HsName] [HsFunDep] [HsClassDecl]- | HsInstDecl SrcLoc HsContext HsQName [HsType] [HsInstDecl]- | HsDerivDecl SrcLoc HsContext HsQName [HsType]- | HsDefaultDecl SrcLoc [HsType]- | HsSpliceDecl SrcLoc HsSplice- | HsTypeSig SrcLoc [HsName] HsType- | HsFunBind [HsMatch]- | HsPatBind SrcLoc HsPat HsRhs {-where-} HsBinds- | HsForImp SrcLoc HsCallConv HsSafety String HsName HsType- | HsForExp SrcLoc HsCallConv String HsName HsType+data Decl+ = TypeDecl SrcLoc Name [Name] Type+ | DataDecl SrcLoc DataOrNew Context Name [Name] [QualConDecl] [QName]+ | GDataDecl SrcLoc DataOrNew Context Name [Name] (Maybe Kind) [GadtDecl] {-no deriving-}+ | TypeFamDecl SrcLoc Name [Name] (Maybe Kind)+ | DataFamDecl SrcLoc Context Name [Name] (Maybe Kind)+ | TypeInsDecl SrcLoc Type Type+ | DataInsDecl SrcLoc DataOrNew Type [QualConDecl] [QName]+ | GDataInsDecl SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] {-no 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 Rhs {-where-} Binds+ | ForImp SrcLoc CallConv Safety String Name Type+ | ForExp SrcLoc CallConv String Name Type #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -309,16 +309,16 @@ deriving (Eq,Show) #endif -data HsBinds- = HsBDecls [HsDecl]- | HsIPBinds [HsIPBind]+data Binds+ = BDecls [Decl]+ | IPBinds [IPBind] #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -data HsIPBind = HsIPBind SrcLoc HsIPName HsExp+data IPBind = IPBind SrcLoc IPName Exp #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -326,26 +326,26 @@ #endif -- | Clauses of a function binding.-data HsMatch- = HsMatch SrcLoc HsName [HsPat] HsRhs {-where-} HsBinds+data Match+ = Match SrcLoc Name [Pat] Rhs {-where-} Binds #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -data HsQualConDecl- = HsQualConDecl SrcLoc - {-forall-} [HsTyVarBind] {- . -} HsContext- {- => -} HsConDecl+data QualConDecl+ = QualConDecl SrcLoc + {-forall-} [TyVarBind] {- . -} Context+ {- => -} ConDecl #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -data HsGadtDecl - = HsGadtDecl SrcLoc HsName HsType+data GadtDecl + = GadtDecl SrcLoc Name Type #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -353,10 +353,10 @@ #endif -- | Declaration of a data constructor.-data HsConDecl- = HsConDecl HsName [HsBangType]+data ConDecl+ = ConDecl Name [BangType] -- ^ ordinary data constructor- | HsRecDecl HsName [([HsName],HsBangType)]+ | RecDecl Name [([Name],BangType)] -- ^ record constructor #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data)@@ -365,11 +365,11 @@ #endif -- | Declarations inside a class declaration-data HsClassDecl- = HsClsDecl HsDecl- | HsClsDataFam SrcLoc HsContext HsName [HsName] (Maybe HsKind)- | HsClsTyFam SrcLoc HsName [HsName] (Maybe HsKind)- | HsClsTyDef SrcLoc HsType HsType+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@@ -377,11 +377,11 @@ #endif -- | Declarations inside an instance declaration-data HsInstDecl- = HsInsDecl HsDecl- | HsInsType SrcLoc HsType HsType- | HsInsData SrcLoc DataOrNew HsType [HsQualConDecl] [HsQName]- | HsInsGData SrcLoc DataOrNew HsType (Maybe HsKind) [HsGadtDecl] {-no deriving-}+data InstDecl+ = InsDecl Decl+ | InsType SrcLoc Type Type+ | InsData SrcLoc DataOrNew Type [QualConDecl] [QName]+ | InsGData SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] {-no deriving-} #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -390,9 +390,9 @@ -- | The type of a constructor argument or field, optionally including -- a strictness annotation.-data HsBangType- = HsBangedTy HsType -- ^ strict component, marked with \"@!@\"- | HsUnBangedTy HsType -- ^ non-strict component+data BangType+ = BangedTy Type -- ^ strict component, marked with \"@!@\"+ | UnBangedTy Type -- ^ non-strict component #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -400,9 +400,9 @@ #endif -- | The right hand side of a function or pattern binding.-data HsRhs- = HsUnGuardedRhs HsExp -- ^ unguarded right hand side (/exp/)- | HsGuardedRhss [HsGuardedRhs]+data Rhs+ = UnGuardedRhs Exp -- ^ unguarded right hand side (/exp/)+ | GuardedRhss [GuardedRhs] -- ^ guarded right hand side (/gdrhs/) #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data)@@ -411,8 +411,8 @@ #endif -- | A guarded right hand side @|@ /exp/ @=@ /exp/. -- The first expression will be Boolean-valued.-data HsGuardedRhs- = HsGuardedRhs SrcLoc [HsStmt] HsExp+data GuardedRhs+ = GuardedRhs SrcLoc [Stmt] Exp #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -422,45 +422,45 @@ -- | A type qualified with a context. -- An unqualified type has an empty context. -data HsType- = HsTyForall - (Maybe [HsTyVarBind])- HsContext- HsType- | HsTyFun HsType HsType -- ^ function type- | HsTyTuple HsBoxed [HsType] -- ^ tuple type, possibly boxed- | HsTyApp HsType HsType -- ^ application of a type constructor- | HsTyVar HsName -- ^ type variable- | HsTyCon HsQName -- ^ named type or type constructor- | HsTyPred HsAsst -- ^ assertion of an implicit parameter- | HsTyInfix HsType HsQName HsType -- ^ infix type constructor- | HsTyKind HsType HsKind -- ^ type with explicit kind signature+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 HsBoxed = Boxed | Unboxed+data Boxed = Boxed | Unboxed #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -data HsTyVarBind - = HsKindedVar HsName HsKind- | HsUnkindedVar HsName+data TyVarBind + = KindedVar Name Kind+ | UnkindedVar Name #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -data HsKind- = HsKindStar- | HsKindBang- | HsKindFn HsKind HsKind+data Kind+ = KindStar+ | KindBang+ | KindFn Kind Kind #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -470,8 +470,8 @@ -- | A functional dependency, given on the form -- l1 l2 ... ln -> r2 r3 .. rn-data HsFunDep- = HsFunDep [HsName] [HsName]+data FunDep+ = FunDep [Name] [Name] #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -479,15 +479,15 @@ #endif -type HsContext = [HsAsst]+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 HsAsst = HsClassA HsQName [HsType]- | HsIParam HsIPName HsType- | HsEqualP HsType HsType+data Asst = ClassA QName [Type]+ | IParam IPName Type+ | EqualP Type Type #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -498,16 +498,16 @@ -- Values of this type hold the abstract value of the literal, not the -- precise string representation used. For example, @10@, @0o12@ and @0xa@ -- have the same representation.-data HsLiteral- = HsChar Char -- ^ character literal- | HsString String -- ^ string literal- | HsInt Integer -- ^ integer literal- | HsFrac Rational -- ^ floating point literal- | HsCharPrim Char -- ^ GHC unboxed character literal- | HsStringPrim String -- ^ GHC unboxed string literal- | HsIntPrim Integer -- ^ GHC unboxed integer literal- | HsFloatPrim Rational -- ^ GHC unboxed float literal- | HsDoublePrim Rational -- ^ GHC unboxed double literal+data Literal+ = Char Char -- ^ character literal+ | String String -- ^ string literal+ | Int Integer -- ^ integer literal+ | Frac Rational -- ^ floating point literal+ | CharPrim Char -- ^ GHC unboxed character literal+ | StringPrim String -- ^ GHC unboxed string literal+ | IntPrim Integer -- ^ GHC unboxed integer literal+ | FloatPrim Rational -- ^ GHC unboxed float literal+ | DoublePrim Rational -- ^ GHC unboxed double literal #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -525,124 +525,110 @@ -- checks, these constructors should not be used. -- -- * The parser does not take precedence and associativity into account,--- so it will leave 'HsInfixApp's associated to the left.+-- so it will leave 'InfixApp's associated to the left. ----- * The 'Language.Haskell.Pretty.Pretty' instance for 'HsExp' does not+-- * The 'Language.Haskell.Exts.Pretty.Pretty' instance for 'Exp' does not -- add parentheses in printing. -data HsExp- = HsVar HsQName -- ^ variable- | HsIPVar HsIPName -- ^ implicit parameter variable- | HsCon HsQName -- ^ data constructor- | HsLit HsLiteral -- ^ literal constant- | HsInfixApp HsExp HsQOp HsExp -- ^ infix application- | HsApp HsExp HsExp -- ^ ordinary application- | HsNegApp HsExp -- ^ negation expression @-@ /exp/- | HsLambda SrcLoc [HsPat] HsExp -- ^ lambda expression- | HsLet HsBinds HsExp -- ^ local declarations with @let@--- | HsDLet [HsIPBind] HsExp -- ^ local declarations of implicit parameters (hugs)--- | HsWith HsExp [HsIPBind] -- ^ local declarations of implicit parameters- | HsIf HsExp HsExp HsExp -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/- | HsCase HsExp [HsAlt] -- ^ @case@ /exp/ @of@ /alts/- | HsDo [HsStmt] -- ^ @do@-expression:+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.- | HsMDo [HsStmt] -- ^ @mdo@-expression- | HsTuple [HsExp] -- ^ tuple expression- | HsList [HsExp] -- ^ list expression- | HsParen HsExp -- ^ parenthesized expression- | HsLeftSection HsExp HsQOp -- ^ left section @(@/exp/ /qop/@)@- | HsRightSection HsQOp HsExp -- ^ right section @(@/qop/ /exp/@)@- | HsRecConstr HsQName [HsFieldUpdate]+ | 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- | HsRecUpdate HsExp [HsFieldUpdate]+ | RecUpdate Exp [FieldUpdate] -- ^ record update expression- | HsEnumFrom HsExp -- ^ unbounded arithmetic sequence,+ | EnumFrom Exp -- ^ unbounded arithmetic sequence, -- incrementing by 1- | HsEnumFromTo HsExp HsExp -- ^ bounded arithmetic sequence,+ | EnumFromTo Exp Exp -- ^ bounded arithmetic sequence, -- incrementing by 1- | HsEnumFromThen HsExp HsExp -- ^ unbounded arithmetic sequence,+ | EnumFromThen Exp Exp -- ^ unbounded arithmetic sequence, -- with first two elements given- | HsEnumFromThenTo HsExp HsExp HsExp+ | EnumFromThenTo Exp Exp Exp -- ^ bounded arithmetic sequence, -- with first two elements given- | HsListComp HsExp [HsStmt] -- ^ list comprehension- | HsExpTypeSig SrcLoc HsExp HsType+ | ListComp Exp [Stmt] -- ^ list comprehension+ | ExpTypeSig SrcLoc Exp Type -- ^ expression type signature- | HsAsPat HsName HsExp -- ^ patterns only- | HsWildCard -- ^ patterns only- | HsIrrPat HsExp -- ^ patterns only+-- | AsPat Name Exp -- ^ patterns only+-- | WildCard -- ^ patterns only+-- | IrrPat Exp -- ^ patterns only +{- -- Post-ops for parsing left sections and regular patterns. Not to be left in the final tree.- | HsPostOp HsExp HsQOp -- ^ post-ops+ | PostOp Exp QOp -- ^ post-ops -- HaRP- | HsSeqRP [HsExp] -- ^ regular patterns only- | HsGuardRP HsExp [HsStmt] -- ^ regular patterns only- | HsEitherRP HsExp HsExp -- ^ regular patterns only- | HsCAsRP HsName HsExp -- ^ regular patterns only- + | SeqRP [Exp] -- ^ regular patterns only+ | GuardRP Exp [Stmt] -- ^ regular patterns only+ | EitherRP Exp Exp -- ^ regular patterns only+ | CAsRP Name Exp -- ^ regular patterns only+-} -- Template Haskell--- | HsReifyExp HsReify- | HsVarQuote HsQName -- ^ 'x- | HsTypQuote HsQName -- ^ ''T- | HsBracketExp HsBracket- | HsSpliceExp HsSplice+ | VarQuote QName -- ^ 'x+ | TypQuote QName -- ^ ''T+ | BracketExp Bracket+ | SpliceExp Splice -- Hsx- | HsXTag SrcLoc HsXName [HsXAttr] (Maybe HsExp) [HsExp]- | HsXETag SrcLoc HsXName [HsXAttr] (Maybe HsExp)- | HsXPcdata String- | HsXExpTag HsExp- | HsXRPats [HsExp]+ | XTag SrcLoc XName [XAttr] (Maybe Exp) [Exp]+ | XETag SrcLoc XName [XAttr] (Maybe Exp)+ | XPcdata String+ | XExpTag Exp+-- | XRPats [Exp] #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -data HsXName - = HsXName String -- <name ...- | HsXDomName String String -- <dom:name ...+data XName + = XName String -- <name ...+ | XDomName String String -- <dom:name ... #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -data HsXAttr = HsXAttr HsXName HsExp+data XAttr = XAttr XName Exp #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -{--data HsReify - = HsReifyType HsQName- | HsReifyDecl HsQName- | HsReifyFixity HsQName-#ifdef __GLASGOW_HASKELL__- deriving (Eq,Show,Typeable,Data)-#else- deriving (Eq,Show)-#endif--}- -data HsBracket- = HsExpBracket HsExp- | HsPatBracket HsPat- | HsTypeBracket HsType- | HsDeclBracket [HsDecl]+data Bracket+ = ExpBracket Exp+ | PatBracket Pat+ | TypeBracket Type+ | DeclBracket [Decl] #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -data HsSplice- = HsIdSplice String- | HsParenSplice HsExp+data Splice+ = IdSplice String+ | ParenSplice Exp #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -651,7 +637,7 @@ -- FFI stuff-data HsSafety+data Safety = PlayRisky | PlaySafe Bool #ifdef __GLASGOW_HASKELL__@@ -660,7 +646,7 @@ deriving (Eq,Show) #endif -data HsCallConv+data CallConv = StdCall | CCall #ifdef __GLASGOW_HASKELL__@@ -672,35 +658,35 @@ -- | A pattern, to be matched against a value.-data HsPat- = HsPVar HsName -- ^ variable- | HsPLit HsLiteral -- ^ literal constant- | HsPNeg HsPat -- ^ negated pattern- | HsPInfixApp HsPat HsQName HsPat+data Pat+ = PVar Name -- ^ variable+ | PLit Literal -- ^ literal constant+ | PNeg Pat -- ^ negated pattern+ | PInfixApp Pat QName Pat -- ^ pattern with infix data constructor- | HsPApp HsQName [HsPat] -- ^ data constructor and argument+ | PApp QName [Pat] -- ^ data constructor and argument -- patterns- | HsPTuple [HsPat] -- ^ tuple pattern- | HsPList [HsPat] -- ^ list pattern- | HsPParen HsPat -- ^ parenthesized pattern- | HsPRec HsQName [HsPatField] -- ^ labelled pattern- | HsPAsPat HsName HsPat -- ^ @\@@-pattern- | HsPWildCard -- ^ wildcard pattern (@_@)- | HsPIrrPat HsPat -- ^ irrefutable pattern (@~@)- | HsPatTypeSig SrcLoc HsPat HsType+ | PTuple [Pat] -- ^ tuple pattern+ | PList [Pat] -- ^ list pattern+ | PParen Pat -- ^ parenthesized pattern+ | PRec QName [PatField] -- ^ labelled pattern+ | PAsPat Name Pat -- ^ @\@@-pattern+ | PWildCard -- ^ wildcard pattern (@_@)+ | PIrrPat Pat -- ^ irrefutable pattern (@~@)+ | PatTypeSig SrcLoc Pat Type -- ^ pattern type signature -- HaRP- | HsPRPat [HsRPat] -- ^ regular pattern (HaRP)+ | PRPat [RPat] -- ^ regular pattern (HaRP) -- Hsx- | HsPXTag SrcLoc HsXName [HsPXAttr] (Maybe HsPat) [HsPat]+ | PXTag SrcLoc XName [PXAttr] (Maybe Pat) [Pat] -- ^ XML tag pattern- | HsPXETag SrcLoc HsXName [HsPXAttr] (Maybe HsPat)+ | PXETag SrcLoc XName [PXAttr] (Maybe Pat) -- ^ XML singleton tag pattern- | HsPXPcdata String+ | PXPcdata String -- ^ XML PCDATA pattern- | HsPXPatTag HsPat+ | PXPatTag Pat -- ^ XML embedded pattern- | HsPXRPats [HsRPat]+ | PXRPats [RPat] -- ^ XML regular list pattern #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data)@@ -709,7 +695,7 @@ #endif -- | An XML attribute in an XML tag pattern -data HsPXAttr = HsPXAttr HsXName HsPat+data PXAttr = PXAttr XName Pat #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -717,13 +703,13 @@ #endif -- | A regular pattern operator (HaRP)-data HsRPatOp- = HsRPStar- | HsRPStarG- | HsRPPlus- | HsRPPlusG- | HsRPOpt- | HsRPOptG+data RPatOp+ = RPStar+ | RPStarG+ | RPPlus+ | RPPlusG+ | RPOpt+ | RPOptG #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -731,15 +717,15 @@ #endif -- | An entity in a regular pattern (HaRP)-data HsRPat- = HsRPOp HsRPat HsRPatOp- | HsRPEither HsRPat HsRPat- | HsRPSeq [HsRPat]- | HsRPGuard HsPat [HsStmt]- | HsRPCAs HsName HsRPat- | HsRPAs HsName HsRPat- | HsRPParen HsRPat- | HsRPPat HsPat+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@@ -747,8 +733,8 @@ #endif -- | An /fpat/ in a labeled record pattern.-data HsPatField- = HsPFieldPat HsQName HsPat+data PatField+ = PFieldPat QName Pat #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -758,13 +744,13 @@ -- | This type represents both /stmt/ in a @do@-expression, -- and /qual/ in a list comprehension, as well as /stmt/ -- in a pattern guard.-data HsStmt- = HsGenerator SrcLoc HsPat HsExp+data Stmt+ = Generator SrcLoc Pat Exp -- ^ a generator /pat/ @<-@ /exp/- | HsQualifier HsExp -- ^ an /exp/ by itself: in a @do@-expression,+ | Qualifier Exp -- ^ an /exp/ by itself: in a @do@-expression, -- an action whose result is discarded; -- in a list comprehension, a guard expression- | HsLetStmt HsBinds -- ^ local bindings+ | LetStmt Binds -- ^ local bindings #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -772,8 +758,8 @@ #endif -- | An /fbind/ in a labeled construction or update.-data HsFieldUpdate- = HsFieldUpdate HsQName HsExp+data FieldUpdate+ = FieldUpdate QName Exp #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -781,17 +767,17 @@ #endif -- | An /alt/ in a @case@ expression.-data HsAlt- = HsAlt SrcLoc HsPat HsGuardedAlts HsBinds+data Alt+ = Alt SrcLoc Pat GuardedAlts Binds #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -data HsGuardedAlts- = HsUnGuardedAlt HsExp -- ^ @->@ /exp/- | HsGuardedAlts [HsGuardedAlt] -- ^ /gdpat/+data GuardedAlts+ = UnGuardedAlt Exp -- ^ @->@ /exp/+ | GuardedAlts [GuardedAlt] -- ^ /gdpat/ #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -799,8 +785,8 @@ #endif -- | A guarded alternative @|@ /stmt/, ... , /stmt/ @->@ /exp/.-data HsGuardedAlt- = HsGuardedAlt SrcLoc [HsStmt] HsExp+data GuardedAlt+ = GuardedAlt SrcLoc [Stmt] Exp #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else@@ -810,57 +796,57 @@ ----------------------------------------------------------------------------- -- Builtin names. -prelude_mod, main_mod :: Module-prelude_mod = Module "Prelude"-main_mod = Module "Main"+prelude_mod, main_mod :: ModuleName+prelude_mod = ModuleName "Prelude"+main_mod = ModuleName "Main" -main_name :: HsName-main_name = HsIdent "main"+main_name :: Name+main_name = Ident "main" -unit_con_name :: HsQName-unit_con_name = Special HsUnitCon+unit_con_name :: QName+unit_con_name = Special UnitCon -tuple_con_name :: Int -> HsQName-tuple_con_name i = Special (HsTupleCon (i+1))+tuple_con_name :: Int -> QName+tuple_con_name i = Special (TupleCon (i+1)) -list_cons_name :: HsQName-list_cons_name = Special HsCons+list_cons_name :: QName+list_cons_name = Special Cons -unit_con :: HsExp-unit_con = HsCon unit_con_name+unit_con :: Exp+unit_con = Con unit_con_name -tuple_con :: Int -> HsExp-tuple_con i = HsCon (tuple_con_name i)+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 :: HsName-as_name = HsIdent "as"-qualified_name = HsIdent "qualified"-hiding_name = HsIdent "hiding"-minus_name = HsSymbol "-"-pling_name = HsSymbol "!"-dot_name = HsSymbol "."-star_name = HsSymbol "*"+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 :: HsName-export_name = HsIdent "export"-safe_name = HsIdent "safe"-unsafe_name = HsIdent "unsafe"-threadsafe_name = HsIdent "threadsafe"-stdcall_name = HsIdent "stdcall"-ccall_name = HsIdent "ccall"+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 :: HsQName+unit_tycon_name, fun_tycon_name, list_tycon_name :: QName unit_tycon_name = unit_con_name-fun_tycon_name = Special HsFunCon-list_tycon_name = Special HsListCon+fun_tycon_name = Special FunCon+list_tycon_name = Special ListCon -tuple_tycon_name :: Int -> HsQName+tuple_tycon_name :: Int -> QName tuple_tycon_name i = tuple_con_name i -unit_tycon, fun_tycon, list_tycon :: HsType-unit_tycon = HsTyCon unit_tycon_name-fun_tycon = HsTyCon fun_tycon_name-list_tycon = HsTyCon list_tycon_name+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 -> HsType-tuple_tycon i = HsTyCon (tuple_tycon_name i)+tuple_tycon :: Int -> Type+tuple_tycon i = TyCon (tuple_tycon_name i)
dist/build/Language/Haskell/Exts/Parser.hs view
@@ -17,5466 +17,5464 @@ parseModule, parseModuleWithMode, ParseMode(..), defaultParseMode, ParseResult(..)) where -import Language.Haskell.Exts.Syntax -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 :: (HsModule) -> (HappyAbsSyn ) -happyIn4 x = unsafeCoerce# x -{-# INLINE happyIn4 #-} -happyOut4 :: (HappyAbsSyn ) -> (HsModule) -happyOut4 x = unsafeCoerce# x -{-# INLINE happyOut4 #-} -happyIn5 :: (HsExp) -> (HappyAbsSyn ) -happyIn5 x = unsafeCoerce# x -{-# INLINE happyIn5 #-} -happyOut5 :: (HappyAbsSyn ) -> (HsExp) -happyOut5 x = unsafeCoerce# x -{-# INLINE happyOut5 #-} -happyIn6 :: (HsModule) -> (HappyAbsSyn ) -happyIn6 x = unsafeCoerce# x -{-# INLINE happyIn6 #-} -happyOut6 :: (HappyAbsSyn ) -> (HsModule) -happyOut6 x = unsafeCoerce# x -{-# INLINE happyOut6 #-} -happyIn7 :: (([HsImportDecl],[HsDecl])) -> (HappyAbsSyn ) -happyIn7 x = unsafeCoerce# x -{-# INLINE happyIn7 #-} -happyOut7 :: (HappyAbsSyn ) -> (([HsImportDecl],[HsDecl])) -happyOut7 x = unsafeCoerce# x -{-# INLINE happyOut7 #-} -happyIn8 :: (([HsImportDecl],[HsDecl])) -> (HappyAbsSyn ) -happyIn8 x = unsafeCoerce# x -{-# INLINE happyIn8 #-} -happyOut8 :: (HappyAbsSyn ) -> (([HsImportDecl],[HsDecl])) -happyOut8 x = unsafeCoerce# x -{-# INLINE happyOut8 #-} -happyIn9 :: (()) -> (HappyAbsSyn ) -happyIn9 x = unsafeCoerce# x -{-# INLINE happyIn9 #-} -happyOut9 :: (HappyAbsSyn ) -> (()) -happyOut9 x = unsafeCoerce# x -{-# INLINE happyOut9 #-} -happyIn10 :: (()) -> (HappyAbsSyn ) -happyIn10 x = unsafeCoerce# x -{-# INLINE happyIn10 #-} -happyOut10 :: (HappyAbsSyn ) -> (()) -happyOut10 x = unsafeCoerce# x -{-# INLINE happyOut10 #-} -happyIn11 :: (Maybe [HsExportSpec]) -> (HappyAbsSyn ) -happyIn11 x = unsafeCoerce# x -{-# INLINE happyIn11 #-} -happyOut11 :: (HappyAbsSyn ) -> (Maybe [HsExportSpec]) -happyOut11 x = unsafeCoerce# x -{-# INLINE happyOut11 #-} -happyIn12 :: ([HsExportSpec]) -> (HappyAbsSyn ) -happyIn12 x = unsafeCoerce# x -{-# INLINE happyIn12 #-} -happyOut12 :: (HappyAbsSyn ) -> ([HsExportSpec]) -happyOut12 x = unsafeCoerce# x -{-# INLINE happyOut12 #-} -happyIn13 :: (()) -> (HappyAbsSyn ) -happyIn13 x = unsafeCoerce# x -{-# INLINE happyIn13 #-} -happyOut13 :: (HappyAbsSyn ) -> (()) -happyOut13 x = unsafeCoerce# x -{-# INLINE happyOut13 #-} -happyIn14 :: ([HsExportSpec]) -> (HappyAbsSyn ) -happyIn14 x = unsafeCoerce# x -{-# INLINE happyIn14 #-} -happyOut14 :: (HappyAbsSyn ) -> ([HsExportSpec]) -happyOut14 x = unsafeCoerce# x -{-# INLINE happyOut14 #-} -happyIn15 :: (HsExportSpec) -> (HappyAbsSyn ) -happyIn15 x = unsafeCoerce# x -{-# INLINE happyIn15 #-} -happyOut15 :: (HappyAbsSyn ) -> (HsExportSpec) -happyOut15 x = unsafeCoerce# x -{-# INLINE happyOut15 #-} -happyIn16 :: ([HsImportDecl]) -> (HappyAbsSyn ) -happyIn16 x = unsafeCoerce# x -{-# INLINE happyIn16 #-} -happyOut16 :: (HappyAbsSyn ) -> ([HsImportDecl]) -happyOut16 x = unsafeCoerce# x -{-# INLINE happyOut16 #-} -happyIn17 :: (HsImportDecl) -> (HappyAbsSyn ) -happyIn17 x = unsafeCoerce# x -{-# INLINE happyIn17 #-} -happyOut17 :: (HappyAbsSyn ) -> (HsImportDecl) -happyOut17 x = unsafeCoerce# x -{-# INLINE happyOut17 #-} -happyIn18 :: (Bool) -> (HappyAbsSyn ) -happyIn18 x = unsafeCoerce# x -{-# INLINE happyIn18 #-} -happyOut18 :: (HappyAbsSyn ) -> (Bool) -happyOut18 x = unsafeCoerce# x -{-# INLINE happyOut18 #-} -happyIn19 :: (Maybe Module) -> (HappyAbsSyn ) -happyIn19 x = unsafeCoerce# x -{-# INLINE happyIn19 #-} -happyOut19 :: (HappyAbsSyn ) -> (Maybe Module) -happyOut19 x = unsafeCoerce# x -{-# INLINE happyOut19 #-} -happyIn20 :: (Maybe (Bool, [HsImportSpec])) -> (HappyAbsSyn ) -happyIn20 x = unsafeCoerce# x -{-# INLINE happyIn20 #-} -happyOut20 :: (HappyAbsSyn ) -> (Maybe (Bool, [HsImportSpec])) -happyOut20 x = unsafeCoerce# x -{-# INLINE happyOut20 #-} -happyIn21 :: ((Bool, [HsImportSpec])) -> (HappyAbsSyn ) -happyIn21 x = unsafeCoerce# x -{-# INLINE happyIn21 #-} -happyOut21 :: (HappyAbsSyn ) -> ((Bool, [HsImportSpec])) -happyOut21 x = unsafeCoerce# x -{-# INLINE happyOut21 #-} -happyIn22 :: (Bool) -> (HappyAbsSyn ) -happyIn22 x = unsafeCoerce# x -{-# INLINE happyIn22 #-} -happyOut22 :: (HappyAbsSyn ) -> (Bool) -happyOut22 x = unsafeCoerce# x -{-# INLINE happyOut22 #-} -happyIn23 :: ([HsImportSpec]) -> (HappyAbsSyn ) -happyIn23 x = unsafeCoerce# x -{-# INLINE happyIn23 #-} -happyOut23 :: (HappyAbsSyn ) -> ([HsImportSpec]) -happyOut23 x = unsafeCoerce# x -{-# INLINE happyOut23 #-} -happyIn24 :: (HsImportSpec) -> (HappyAbsSyn ) -happyIn24 x = unsafeCoerce# x -{-# INLINE happyIn24 #-} -happyOut24 :: (HappyAbsSyn ) -> (HsImportSpec) -happyOut24 x = unsafeCoerce# x -{-# INLINE happyOut24 #-} -happyIn25 :: ([HsCName]) -> (HappyAbsSyn ) -happyIn25 x = unsafeCoerce# x -{-# INLINE happyIn25 #-} -happyOut25 :: (HappyAbsSyn ) -> ([HsCName]) -happyOut25 x = unsafeCoerce# x -{-# INLINE happyOut25 #-} -happyIn26 :: (HsCName) -> (HappyAbsSyn ) -happyIn26 x = unsafeCoerce# x -{-# INLINE happyIn26 #-} -happyOut26 :: (HappyAbsSyn ) -> (HsCName) -happyOut26 x = unsafeCoerce# x -{-# INLINE happyOut26 #-} -happyIn27 :: (HsDecl) -> (HappyAbsSyn ) -happyIn27 x = unsafeCoerce# x -{-# INLINE happyIn27 #-} -happyOut27 :: (HappyAbsSyn ) -> (HsDecl) -happyOut27 x = unsafeCoerce# x -{-# INLINE happyOut27 #-} -happyIn28 :: (Int) -> (HappyAbsSyn ) -happyIn28 x = unsafeCoerce# x -{-# INLINE happyIn28 #-} -happyOut28 :: (HappyAbsSyn ) -> (Int) -happyOut28 x = unsafeCoerce# x -{-# INLINE happyOut28 #-} -happyIn29 :: (HsAssoc) -> (HappyAbsSyn ) -happyIn29 x = unsafeCoerce# x -{-# INLINE happyIn29 #-} -happyOut29 :: (HappyAbsSyn ) -> (HsAssoc) -happyOut29 x = unsafeCoerce# x -{-# INLINE happyOut29 #-} -happyIn30 :: ([HsOp]) -> (HappyAbsSyn ) -happyIn30 x = unsafeCoerce# x -{-# INLINE happyIn30 #-} -happyOut30 :: (HappyAbsSyn ) -> ([HsOp]) -happyOut30 x = unsafeCoerce# x -{-# INLINE happyOut30 #-} -happyIn31 :: ([HsDecl]) -> (HappyAbsSyn ) -happyIn31 x = unsafeCoerce# x -{-# INLINE happyIn31 #-} -happyOut31 :: (HappyAbsSyn ) -> ([HsDecl]) -happyOut31 x = unsafeCoerce# x -{-# INLINE happyOut31 #-} -happyIn32 :: ([HsDecl]) -> (HappyAbsSyn ) -happyIn32 x = unsafeCoerce# x -{-# INLINE happyIn32 #-} -happyOut32 :: (HappyAbsSyn ) -> ([HsDecl]) -happyOut32 x = unsafeCoerce# x -{-# INLINE happyOut32 #-} -happyIn33 :: (HsDecl) -> (HappyAbsSyn ) -happyIn33 x = unsafeCoerce# x -{-# INLINE happyIn33 #-} -happyOut33 :: (HappyAbsSyn ) -> (HsDecl) -happyOut33 x = unsafeCoerce# x -{-# INLINE happyOut33 #-} -happyIn34 :: (DataOrNew) -> (HappyAbsSyn ) -happyIn34 x = unsafeCoerce# x -{-# INLINE happyIn34 #-} -happyOut34 :: (HappyAbsSyn ) -> (DataOrNew) -happyOut34 x = unsafeCoerce# x -{-# INLINE happyOut34 #-} -happyIn35 :: ([HsType]) -> (HappyAbsSyn ) -happyIn35 x = unsafeCoerce# x -{-# INLINE happyIn35 #-} -happyOut35 :: (HappyAbsSyn ) -> ([HsType]) -happyOut35 x = unsafeCoerce# x -{-# INLINE happyOut35 #-} -happyIn36 :: ([HsDecl]) -> (HappyAbsSyn ) -happyIn36 x = unsafeCoerce# x -{-# INLINE happyIn36 #-} -happyOut36 :: (HappyAbsSyn ) -> ([HsDecl]) -happyOut36 x = unsafeCoerce# x -{-# INLINE happyOut36 #-} -happyIn37 :: ([HsDecl]) -> (HappyAbsSyn ) -happyIn37 x = unsafeCoerce# x -{-# INLINE happyIn37 #-} -happyOut37 :: (HappyAbsSyn ) -> ([HsDecl]) -happyOut37 x = unsafeCoerce# x -{-# INLINE happyOut37 #-} -happyIn38 :: (HsDecl) -> (HappyAbsSyn ) -happyIn38 x = unsafeCoerce# x -{-# INLINE happyIn38 #-} -happyOut38 :: (HappyAbsSyn ) -> (HsDecl) -happyOut38 x = unsafeCoerce# x -{-# INLINE happyOut38 #-} -happyIn39 :: ([HsDecl]) -> (HappyAbsSyn ) -happyIn39 x = unsafeCoerce# x -{-# INLINE happyIn39 #-} -happyOut39 :: (HappyAbsSyn ) -> ([HsDecl]) -happyOut39 x = unsafeCoerce# x -{-# INLINE happyOut39 #-} -happyIn40 :: (HsDecl) -> (HappyAbsSyn ) -happyIn40 x = unsafeCoerce# x -{-# INLINE happyIn40 #-} -happyOut40 :: (HappyAbsSyn ) -> (HsDecl) -happyOut40 x = unsafeCoerce# x -{-# INLINE happyOut40 #-} -happyIn41 :: (HsBinds) -> (HappyAbsSyn ) -happyIn41 x = unsafeCoerce# x -{-# INLINE happyIn41 #-} -happyOut41 :: (HappyAbsSyn ) -> (HsBinds) -happyOut41 x = unsafeCoerce# x -{-# INLINE happyOut41 #-} -happyIn42 :: ([HsName]) -> (HappyAbsSyn ) -happyIn42 x = unsafeCoerce# x -{-# INLINE happyIn42 #-} -happyOut42 :: (HappyAbsSyn ) -> ([HsName]) -happyOut42 x = unsafeCoerce# x -{-# INLINE happyOut42 #-} -happyIn43 :: (HsCallConv) -> (HappyAbsSyn ) -happyIn43 x = unsafeCoerce# x -{-# INLINE happyIn43 #-} -happyOut43 :: (HappyAbsSyn ) -> (HsCallConv) -happyOut43 x = unsafeCoerce# x -{-# INLINE happyOut43 #-} -happyIn44 :: (HsSafety) -> (HappyAbsSyn ) -happyIn44 x = unsafeCoerce# x -{-# INLINE happyIn44 #-} -happyOut44 :: (HappyAbsSyn ) -> (HsSafety) -happyOut44 x = unsafeCoerce# x -{-# INLINE happyOut44 #-} -happyIn45 :: ((String, HsName, HsType)) -> (HappyAbsSyn ) -happyIn45 x = unsafeCoerce# x -{-# INLINE happyIn45 #-} -happyOut45 :: (HappyAbsSyn ) -> ((String, HsName, HsType)) -happyOut45 x = unsafeCoerce# x -{-# INLINE happyOut45 #-} -happyIn46 :: (HsType) -> (HappyAbsSyn ) -happyIn46 x = unsafeCoerce# x -{-# INLINE happyIn46 #-} -happyOut46 :: (HappyAbsSyn ) -> (HsType) -happyOut46 x = unsafeCoerce# x -{-# INLINE happyOut46 #-} -happyIn47 :: (HsType) -> (HappyAbsSyn ) -happyIn47 x = unsafeCoerce# x -{-# INLINE happyIn47 #-} -happyOut47 :: (HappyAbsSyn ) -> (HsType) -happyOut47 x = unsafeCoerce# x -{-# INLINE happyOut47 #-} -happyIn48 :: (HsType) -> (HappyAbsSyn ) -happyIn48 x = unsafeCoerce# x -{-# INLINE happyIn48 #-} -happyOut48 :: (HappyAbsSyn ) -> (HsType) -happyOut48 x = unsafeCoerce# x -{-# INLINE happyOut48 #-} -happyIn49 :: (HsType) -> (HappyAbsSyn ) -happyIn49 x = unsafeCoerce# x -{-# INLINE happyIn49 #-} -happyOut49 :: (HappyAbsSyn ) -> (HsType) -happyOut49 x = unsafeCoerce# x -{-# INLINE happyOut49 #-} -happyIn50 :: (HsQName) -> (HappyAbsSyn ) -happyIn50 x = unsafeCoerce# x -{-# INLINE happyIn50 #-} -happyOut50 :: (HappyAbsSyn ) -> (HsQName) -happyOut50 x = unsafeCoerce# x -{-# INLINE happyOut50 #-} -happyIn51 :: (HsQName) -> (HappyAbsSyn ) -happyIn51 x = unsafeCoerce# x -{-# INLINE happyIn51 #-} -happyOut51 :: (HappyAbsSyn ) -> (HsQName) -happyOut51 x = unsafeCoerce# x -{-# INLINE happyOut51 #-} -happyIn52 :: (HsType) -> (HappyAbsSyn ) -happyIn52 x = unsafeCoerce# x -{-# INLINE happyIn52 #-} -happyOut52 :: (HappyAbsSyn ) -> (HsType) -happyOut52 x = unsafeCoerce# x -{-# INLINE happyOut52 #-} -happyIn53 :: (HsContext) -> (HappyAbsSyn ) -happyIn53 x = unsafeCoerce# x -{-# INLINE happyIn53 #-} -happyOut53 :: (HappyAbsSyn ) -> (HsContext) -happyOut53 x = unsafeCoerce# x -{-# INLINE happyOut53 #-} -happyIn54 :: ([HsType]) -> (HappyAbsSyn ) -happyIn54 x = unsafeCoerce# x -{-# INLINE happyIn54 #-} -happyOut54 :: (HappyAbsSyn ) -> ([HsType]) -happyOut54 x = unsafeCoerce# x -{-# INLINE happyOut54 #-} -happyIn55 :: ([HsType]) -> (HappyAbsSyn ) -happyIn55 x = unsafeCoerce# x -{-# INLINE happyIn55 #-} -happyOut55 :: (HappyAbsSyn ) -> ([HsType]) -happyOut55 x = unsafeCoerce# x -{-# INLINE happyOut55 #-} -happyIn56 :: ([HsTyVarBind]) -> (HappyAbsSyn ) -happyIn56 x = unsafeCoerce# x -{-# INLINE happyIn56 #-} -happyOut56 :: (HappyAbsSyn ) -> ([HsTyVarBind]) -happyOut56 x = unsafeCoerce# x -{-# INLINE happyOut56 #-} -happyIn57 :: (HsTyVarBind) -> (HappyAbsSyn ) -happyIn57 x = unsafeCoerce# x -{-# INLINE happyIn57 #-} -happyOut57 :: (HappyAbsSyn ) -> (HsTyVarBind) -happyOut57 x = unsafeCoerce# x -{-# INLINE happyOut57 #-} -happyIn58 :: ([HsName]) -> (HappyAbsSyn ) -happyIn58 x = unsafeCoerce# x -{-# INLINE happyIn58 #-} -happyOut58 :: (HappyAbsSyn ) -> ([HsName]) -happyOut58 x = unsafeCoerce# x -{-# INLINE happyOut58 #-} -happyIn59 :: ([HsFunDep]) -> (HappyAbsSyn ) -happyIn59 x = unsafeCoerce# x -{-# INLINE happyIn59 #-} -happyOut59 :: (HappyAbsSyn ) -> ([HsFunDep]) -happyOut59 x = unsafeCoerce# x -{-# INLINE happyOut59 #-} -happyIn60 :: ([HsFunDep]) -> (HappyAbsSyn ) -happyIn60 x = unsafeCoerce# x -{-# INLINE happyIn60 #-} -happyOut60 :: (HappyAbsSyn ) -> ([HsFunDep]) -happyOut60 x = unsafeCoerce# x -{-# INLINE happyOut60 #-} -happyIn61 :: (HsFunDep) -> (HappyAbsSyn ) -happyIn61 x = unsafeCoerce# x -{-# INLINE happyIn61 #-} -happyOut61 :: (HappyAbsSyn ) -> (HsFunDep) -happyOut61 x = unsafeCoerce# x -{-# INLINE happyOut61 #-} -happyIn62 :: ([HsGadtDecl]) -> (HappyAbsSyn ) -happyIn62 x = unsafeCoerce# x -{-# INLINE happyIn62 #-} -happyOut62 :: (HappyAbsSyn ) -> ([HsGadtDecl]) -happyOut62 x = unsafeCoerce# x -{-# INLINE happyOut62 #-} -happyIn63 :: ([HsGadtDecl]) -> (HappyAbsSyn ) -happyIn63 x = unsafeCoerce# x -{-# INLINE happyIn63 #-} -happyOut63 :: (HappyAbsSyn ) -> ([HsGadtDecl]) -happyOut63 x = unsafeCoerce# x -{-# INLINE happyOut63 #-} -happyIn64 :: ([HsGadtDecl]) -> (HappyAbsSyn ) -happyIn64 x = unsafeCoerce# x -{-# INLINE happyIn64 #-} -happyOut64 :: (HappyAbsSyn ) -> ([HsGadtDecl]) -happyOut64 x = unsafeCoerce# x -{-# INLINE happyOut64 #-} -happyIn65 :: (HsGadtDecl) -> (HappyAbsSyn ) -happyIn65 x = unsafeCoerce# x -{-# INLINE happyIn65 #-} -happyOut65 :: (HappyAbsSyn ) -> (HsGadtDecl) -happyOut65 x = unsafeCoerce# x -{-# INLINE happyOut65 #-} -happyIn66 :: ([HsQualConDecl]) -> (HappyAbsSyn ) -happyIn66 x = unsafeCoerce# x -{-# INLINE happyIn66 #-} -happyOut66 :: (HappyAbsSyn ) -> ([HsQualConDecl]) -happyOut66 x = unsafeCoerce# x -{-# INLINE happyOut66 #-} -happyIn67 :: ([HsQualConDecl]) -> (HappyAbsSyn ) -happyIn67 x = unsafeCoerce# x -{-# INLINE happyIn67 #-} -happyOut67 :: (HappyAbsSyn ) -> ([HsQualConDecl]) -happyOut67 x = unsafeCoerce# x -{-# INLINE happyOut67 #-} -happyIn68 :: (HsQualConDecl) -> (HappyAbsSyn ) -happyIn68 x = unsafeCoerce# x -{-# INLINE happyIn68 #-} -happyOut68 :: (HappyAbsSyn ) -> (HsQualConDecl) -happyOut68 x = unsafeCoerce# x -{-# INLINE happyOut68 #-} -happyIn69 :: ([HsTyVarBind]) -> (HappyAbsSyn ) -happyIn69 x = unsafeCoerce# x -{-# INLINE happyIn69 #-} -happyOut69 :: (HappyAbsSyn ) -> ([HsTyVarBind]) -happyOut69 x = unsafeCoerce# x -{-# INLINE happyOut69 #-} -happyIn70 :: (HsConDecl) -> (HappyAbsSyn ) -happyIn70 x = unsafeCoerce# x -{-# INLINE happyIn70 #-} -happyOut70 :: (HappyAbsSyn ) -> (HsConDecl) -happyOut70 x = unsafeCoerce# x -{-# INLINE happyOut70 #-} -happyIn71 :: ((HsName, [HsBangType])) -> (HappyAbsSyn ) -happyIn71 x = unsafeCoerce# x -{-# INLINE happyIn71 #-} -happyOut71 :: (HappyAbsSyn ) -> ((HsName, [HsBangType])) -happyOut71 x = unsafeCoerce# x -{-# INLINE happyOut71 #-} -happyIn72 :: ((HsName, [HsBangType])) -> (HappyAbsSyn ) -happyIn72 x = unsafeCoerce# x -{-# INLINE happyIn72 #-} -happyOut72 :: (HappyAbsSyn ) -> ((HsName, [HsBangType])) -happyOut72 x = unsafeCoerce# x -{-# INLINE happyOut72 #-} -happyIn73 :: (HsBangType) -> (HappyAbsSyn ) -happyIn73 x = unsafeCoerce# x -{-# INLINE happyIn73 #-} -happyOut73 :: (HappyAbsSyn ) -> (HsBangType) -happyOut73 x = unsafeCoerce# x -{-# INLINE happyOut73 #-} -happyIn74 :: (HsBangType) -> (HappyAbsSyn ) -happyIn74 x = unsafeCoerce# x -{-# INLINE happyIn74 #-} -happyOut74 :: (HappyAbsSyn ) -> (HsBangType) -happyOut74 x = unsafeCoerce# x -{-# INLINE happyOut74 #-} -happyIn75 :: ([([HsName],HsBangType)]) -> (HappyAbsSyn ) -happyIn75 x = unsafeCoerce# x -{-# INLINE happyIn75 #-} -happyOut75 :: (HappyAbsSyn ) -> ([([HsName],HsBangType)]) -happyOut75 x = unsafeCoerce# x -{-# INLINE happyOut75 #-} -happyIn76 :: (([HsName],HsBangType)) -> (HappyAbsSyn ) -happyIn76 x = unsafeCoerce# x -{-# INLINE happyIn76 #-} -happyOut76 :: (HappyAbsSyn ) -> (([HsName],HsBangType)) -happyOut76 x = unsafeCoerce# x -{-# INLINE happyOut76 #-} -happyIn77 :: (HsBangType) -> (HappyAbsSyn ) -happyIn77 x = unsafeCoerce# x -{-# INLINE happyIn77 #-} -happyOut77 :: (HappyAbsSyn ) -> (HsBangType) -happyOut77 x = unsafeCoerce# x -{-# INLINE happyOut77 #-} -happyIn78 :: ([HsQName]) -> (HappyAbsSyn ) -happyIn78 x = unsafeCoerce# x -{-# INLINE happyIn78 #-} -happyOut78 :: (HappyAbsSyn ) -> ([HsQName]) -happyOut78 x = unsafeCoerce# x -{-# INLINE happyOut78 #-} -happyIn79 :: ([HsQName]) -> (HappyAbsSyn ) -happyIn79 x = unsafeCoerce# x -{-# INLINE happyIn79 #-} -happyOut79 :: (HappyAbsSyn ) -> ([HsQName]) -happyOut79 x = unsafeCoerce# x -{-# INLINE happyOut79 #-} -happyIn80 :: (HsKind) -> (HappyAbsSyn ) -happyIn80 x = unsafeCoerce# x -{-# INLINE happyIn80 #-} -happyOut80 :: (HappyAbsSyn ) -> (HsKind) -happyOut80 x = unsafeCoerce# x -{-# INLINE happyOut80 #-} -happyIn81 :: (HsKind) -> (HappyAbsSyn ) -happyIn81 x = unsafeCoerce# x -{-# INLINE happyIn81 #-} -happyOut81 :: (HappyAbsSyn ) -> (HsKind) -happyOut81 x = unsafeCoerce# x -{-# INLINE happyOut81 #-} -happyIn82 :: (Maybe HsKind) -> (HappyAbsSyn ) -happyIn82 x = unsafeCoerce# x -{-# INLINE happyIn82 #-} -happyOut82 :: (HappyAbsSyn ) -> (Maybe HsKind) -happyOut82 x = unsafeCoerce# x -{-# INLINE happyOut82 #-} -happyIn83 :: ([HsClassDecl]) -> (HappyAbsSyn ) -happyIn83 x = unsafeCoerce# x -{-# INLINE happyIn83 #-} -happyOut83 :: (HappyAbsSyn ) -> ([HsClassDecl]) -happyOut83 x = unsafeCoerce# x -{-# INLINE happyOut83 #-} -happyIn84 :: ([HsClassDecl]) -> (HappyAbsSyn ) -happyIn84 x = unsafeCoerce# x -{-# INLINE happyIn84 #-} -happyOut84 :: (HappyAbsSyn ) -> ([HsClassDecl]) -happyOut84 x = unsafeCoerce# x -{-# INLINE happyOut84 #-} -happyIn85 :: ([HsClassDecl]) -> (HappyAbsSyn ) -happyIn85 x = unsafeCoerce# x -{-# INLINE happyIn85 #-} -happyOut85 :: (HappyAbsSyn ) -> ([HsClassDecl]) -happyOut85 x = unsafeCoerce# x -{-# INLINE happyOut85 #-} -happyIn86 :: ([HsClassDecl]) -> (HappyAbsSyn ) -happyIn86 x = unsafeCoerce# x -{-# INLINE happyIn86 #-} -happyOut86 :: (HappyAbsSyn ) -> ([HsClassDecl]) -happyOut86 x = unsafeCoerce# x -{-# INLINE happyOut86 #-} -happyIn87 :: (HsClassDecl) -> (HappyAbsSyn ) -happyIn87 x = unsafeCoerce# x -{-# INLINE happyIn87 #-} -happyOut87 :: (HappyAbsSyn ) -> (HsClassDecl) -happyOut87 x = unsafeCoerce# x -{-# INLINE happyOut87 #-} -happyIn88 :: (HsClassDecl) -> (HappyAbsSyn ) -happyIn88 x = unsafeCoerce# x -{-# INLINE happyIn88 #-} -happyOut88 :: (HappyAbsSyn ) -> (HsClassDecl) -happyOut88 x = unsafeCoerce# x -{-# INLINE happyOut88 #-} -happyIn89 :: ([HsInstDecl]) -> (HappyAbsSyn ) -happyIn89 x = unsafeCoerce# x -{-# INLINE happyIn89 #-} -happyOut89 :: (HappyAbsSyn ) -> ([HsInstDecl]) -happyOut89 x = unsafeCoerce# x -{-# INLINE happyOut89 #-} -happyIn90 :: ([HsInstDecl]) -> (HappyAbsSyn ) -happyIn90 x = unsafeCoerce# x -{-# INLINE happyIn90 #-} -happyOut90 :: (HappyAbsSyn ) -> ([HsInstDecl]) -happyOut90 x = unsafeCoerce# x -{-# INLINE happyOut90 #-} -happyIn91 :: ([HsInstDecl]) -> (HappyAbsSyn ) -happyIn91 x = unsafeCoerce# x -{-# INLINE happyIn91 #-} -happyOut91 :: (HappyAbsSyn ) -> ([HsInstDecl]) -happyOut91 x = unsafeCoerce# x -{-# INLINE happyOut91 #-} -happyIn92 :: (HsInstDecl) -> (HappyAbsSyn ) -happyIn92 x = unsafeCoerce# x -{-# INLINE happyIn92 #-} -happyOut92 :: (HappyAbsSyn ) -> (HsInstDecl) -happyOut92 x = unsafeCoerce# x -{-# INLINE happyOut92 #-} -happyIn93 :: (HsInstDecl) -> (HappyAbsSyn ) -happyIn93 x = unsafeCoerce# x -{-# INLINE happyIn93 #-} -happyOut93 :: (HappyAbsSyn ) -> (HsInstDecl) -happyOut93 x = unsafeCoerce# x -{-# INLINE happyOut93 #-} -happyIn94 :: (HsDecl) -> (HappyAbsSyn ) -happyIn94 x = unsafeCoerce# x -{-# INLINE happyIn94 #-} -happyOut94 :: (HappyAbsSyn ) -> (HsDecl) -happyOut94 x = unsafeCoerce# x -{-# INLINE happyOut94 #-} -happyIn95 :: (HsBinds) -> (HappyAbsSyn ) -happyIn95 x = unsafeCoerce# x -{-# INLINE happyIn95 #-} -happyOut95 :: (HappyAbsSyn ) -> (HsBinds) -happyOut95 x = unsafeCoerce# x -{-# INLINE happyOut95 #-} -happyIn96 :: (HsRhs) -> (HappyAbsSyn ) -happyIn96 x = unsafeCoerce# x -{-# INLINE happyIn96 #-} -happyOut96 :: (HappyAbsSyn ) -> (HsRhs) -happyOut96 x = unsafeCoerce# x -{-# INLINE happyOut96 #-} -happyIn97 :: ([HsGuardedRhs]) -> (HappyAbsSyn ) -happyIn97 x = unsafeCoerce# x -{-# INLINE happyIn97 #-} -happyOut97 :: (HappyAbsSyn ) -> ([HsGuardedRhs]) -happyOut97 x = unsafeCoerce# x -{-# INLINE happyOut97 #-} -happyIn98 :: (HsGuardedRhs) -> (HappyAbsSyn ) -happyIn98 x = unsafeCoerce# x -{-# INLINE happyIn98 #-} -happyOut98 :: (HappyAbsSyn ) -> (HsGuardedRhs) -happyOut98 x = unsafeCoerce# x -{-# INLINE happyOut98 #-} -happyIn99 :: (HsExp) -> (HappyAbsSyn ) -happyIn99 x = unsafeCoerce# x -{-# INLINE happyIn99 #-} -happyOut99 :: (HappyAbsSyn ) -> (HsExp) -happyOut99 x = unsafeCoerce# x -{-# INLINE happyOut99 #-} -happyIn100 :: (HsExp) -> (HappyAbsSyn ) -happyIn100 x = unsafeCoerce# x -{-# INLINE happyIn100 #-} -happyOut100 :: (HappyAbsSyn ) -> (HsExp) -happyOut100 x = unsafeCoerce# x -{-# INLINE happyOut100 #-} -happyIn101 :: (HsExp) -> (HappyAbsSyn ) -happyIn101 x = unsafeCoerce# x -{-# INLINE happyIn101 #-} -happyOut101 :: (HappyAbsSyn ) -> (HsExp) -happyOut101 x = unsafeCoerce# x -{-# INLINE happyOut101 #-} -happyIn102 :: (HsExp) -> (HappyAbsSyn ) -happyIn102 x = unsafeCoerce# x -{-# INLINE happyIn102 #-} -happyOut102 :: (HappyAbsSyn ) -> (HsExp) -happyOut102 x = unsafeCoerce# x -{-# INLINE happyOut102 #-} -happyIn103 :: (HsExp) -> (HappyAbsSyn ) -happyIn103 x = unsafeCoerce# x -{-# INLINE happyIn103 #-} -happyOut103 :: (HappyAbsSyn ) -> (HsExp) -happyOut103 x = unsafeCoerce# x -{-# INLINE happyOut103 #-} -happyIn104 :: (HsExp) -> (HappyAbsSyn ) -happyIn104 x = unsafeCoerce# x -{-# INLINE happyIn104 #-} -happyOut104 :: (HappyAbsSyn ) -> (HsExp) -happyOut104 x = unsafeCoerce# x -{-# INLINE happyOut104 #-} -happyIn105 :: (HsExp) -> (HappyAbsSyn ) -happyIn105 x = unsafeCoerce# x -{-# INLINE happyIn105 #-} -happyOut105 :: (HappyAbsSyn ) -> (HsExp) -happyOut105 x = unsafeCoerce# x -{-# INLINE happyOut105 #-} -happyIn106 :: ([HsPat]) -> (HappyAbsSyn ) -happyIn106 x = unsafeCoerce# x -{-# INLINE happyIn106 #-} -happyOut106 :: (HappyAbsSyn ) -> ([HsPat]) -happyOut106 x = unsafeCoerce# x -{-# INLINE happyOut106 #-} -happyIn107 :: (HsPat) -> (HappyAbsSyn ) -happyIn107 x = unsafeCoerce# x -{-# INLINE happyIn107 #-} -happyOut107 :: (HappyAbsSyn ) -> (HsPat) -happyOut107 x = unsafeCoerce# x -{-# INLINE happyOut107 #-} -happyIn108 :: (HsExp) -> (HappyAbsSyn ) -happyIn108 x = unsafeCoerce# x -{-# INLINE happyIn108 #-} -happyOut108 :: (HappyAbsSyn ) -> (HsExp) -happyOut108 x = unsafeCoerce# x -{-# INLINE happyOut108 #-} -happyIn109 :: (HsExp) -> (HappyAbsSyn ) -happyIn109 x = unsafeCoerce# x -{-# INLINE happyIn109 #-} -happyOut109 :: (HappyAbsSyn ) -> (HsExp) -happyOut109 x = unsafeCoerce# x -{-# INLINE happyOut109 #-} -happyIn110 :: (HsExp) -> (HappyAbsSyn ) -happyIn110 x = unsafeCoerce# x -{-# INLINE happyIn110 #-} -happyOut110 :: (HappyAbsSyn ) -> (HsExp) -happyOut110 x = unsafeCoerce# x -{-# INLINE happyOut110 #-} -happyIn111 :: (Int) -> (HappyAbsSyn ) -happyIn111 x = unsafeCoerce# x -{-# INLINE happyIn111 #-} -happyOut111 :: (HappyAbsSyn ) -> (Int) -happyOut111 x = unsafeCoerce# x -{-# INLINE happyOut111 #-} -happyIn112 :: ([HsExp]) -> (HappyAbsSyn ) -happyIn112 x = unsafeCoerce# x -{-# INLINE happyIn112 #-} -happyOut112 :: (HappyAbsSyn ) -> ([HsExp]) -happyOut112 x = unsafeCoerce# x -{-# INLINE happyOut112 #-} -happyIn113 :: ([HsExp]) -> (HappyAbsSyn ) -happyIn113 x = unsafeCoerce# x -{-# INLINE happyIn113 #-} -happyOut113 :: (HappyAbsSyn ) -> ([HsExp]) -happyOut113 x = unsafeCoerce# x -{-# INLINE happyOut113 #-} -happyIn114 :: (HsExp) -> (HappyAbsSyn ) -happyIn114 x = unsafeCoerce# x -{-# INLINE happyIn114 #-} -happyOut114 :: (HappyAbsSyn ) -> (HsExp) -happyOut114 x = unsafeCoerce# x -{-# INLINE happyOut114 #-} -happyIn115 :: (HsExp) -> (HappyAbsSyn ) -happyIn115 x = unsafeCoerce# x -{-# INLINE happyIn115 #-} -happyOut115 :: (HappyAbsSyn ) -> (HsExp) -happyOut115 x = unsafeCoerce# x -{-# INLINE happyOut115 #-} -happyIn116 :: ([HsExp]) -> (HappyAbsSyn ) -happyIn116 x = unsafeCoerce# x -{-# INLINE happyIn116 #-} -happyOut116 :: (HappyAbsSyn ) -> ([HsExp]) -happyOut116 x = unsafeCoerce# x -{-# INLINE happyOut116 #-} -happyIn117 :: (HsExp) -> (HappyAbsSyn ) -happyIn117 x = unsafeCoerce# x -{-# INLINE happyIn117 #-} -happyOut117 :: (HappyAbsSyn ) -> (HsExp) -happyOut117 x = unsafeCoerce# x -{-# INLINE happyOut117 #-} -happyIn118 :: (HsXName) -> (HappyAbsSyn ) -happyIn118 x = unsafeCoerce# x -{-# INLINE happyIn118 #-} -happyOut118 :: (HappyAbsSyn ) -> (HsXName) -happyOut118 x = unsafeCoerce# x -{-# INLINE happyOut118 #-} -happyIn119 :: (String) -> (HappyAbsSyn ) -happyIn119 x = unsafeCoerce# x -{-# INLINE happyIn119 #-} -happyOut119 :: (HappyAbsSyn ) -> (String) -happyOut119 x = unsafeCoerce# x -{-# INLINE happyOut119 #-} -happyIn120 :: ([HsXAttr]) -> (HappyAbsSyn ) -happyIn120 x = unsafeCoerce# x -{-# INLINE happyIn120 #-} -happyOut120 :: (HappyAbsSyn ) -> ([HsXAttr]) -happyOut120 x = unsafeCoerce# x -{-# INLINE happyOut120 #-} -happyIn121 :: (HsXAttr) -> (HappyAbsSyn ) -happyIn121 x = unsafeCoerce# x -{-# INLINE happyIn121 #-} -happyOut121 :: (HappyAbsSyn ) -> (HsXAttr) -happyOut121 x = unsafeCoerce# x -{-# INLINE happyOut121 #-} -happyIn122 :: (Maybe HsExp) -> (HappyAbsSyn ) -happyIn122 x = unsafeCoerce# x -{-# INLINE happyIn122 #-} -happyOut122 :: (HappyAbsSyn ) -> (Maybe HsExp) -happyOut122 x = unsafeCoerce# x -{-# INLINE happyOut122 #-} -happyIn123 :: (HsExp) -> (HappyAbsSyn ) -happyIn123 x = unsafeCoerce# x -{-# INLINE happyIn123 #-} -happyOut123 :: (HappyAbsSyn ) -> (HsExp) -happyOut123 x = unsafeCoerce# x -{-# INLINE happyOut123 #-} -happyIn124 :: (HsExp) -> (HappyAbsSyn ) -happyIn124 x = unsafeCoerce# x -{-# INLINE happyIn124 #-} -happyOut124 :: (HappyAbsSyn ) -> (HsExp) -happyOut124 x = unsafeCoerce# x -{-# INLINE happyOut124 #-} -happyIn125 :: ([HsExp]) -> (HappyAbsSyn ) -happyIn125 x = unsafeCoerce# x -{-# INLINE happyIn125 #-} -happyOut125 :: (HappyAbsSyn ) -> ([HsExp]) -happyOut125 x = unsafeCoerce# x -{-# INLINE happyOut125 #-} -happyIn126 :: ([HsStmt]) -> (HappyAbsSyn ) -happyIn126 x = unsafeCoerce# x -{-# INLINE happyIn126 #-} -happyOut126 :: (HappyAbsSyn ) -> ([HsStmt]) -happyOut126 x = unsafeCoerce# x -{-# INLINE happyOut126 #-} -happyIn127 :: ([HsStmt]) -> (HappyAbsSyn ) -happyIn127 x = unsafeCoerce# x -{-# INLINE happyIn127 #-} -happyOut127 :: (HappyAbsSyn ) -> ([HsStmt]) -happyOut127 x = unsafeCoerce# x -{-# INLINE happyOut127 #-} -happyIn128 :: (HsStmt) -> (HappyAbsSyn ) -happyIn128 x = unsafeCoerce# x -{-# INLINE happyIn128 #-} -happyOut128 :: (HappyAbsSyn ) -> (HsStmt) -happyOut128 x = unsafeCoerce# x -{-# INLINE happyOut128 #-} -happyIn129 :: ([HsAlt]) -> (HappyAbsSyn ) -happyIn129 x = unsafeCoerce# x -{-# INLINE happyIn129 #-} -happyOut129 :: (HappyAbsSyn ) -> ([HsAlt]) -happyOut129 x = unsafeCoerce# x -{-# INLINE happyOut129 #-} -happyIn130 :: ([HsAlt]) -> (HappyAbsSyn ) -happyIn130 x = unsafeCoerce# x -{-# INLINE happyIn130 #-} -happyOut130 :: (HappyAbsSyn ) -> ([HsAlt]) -happyOut130 x = unsafeCoerce# x -{-# INLINE happyOut130 #-} -happyIn131 :: ([HsAlt]) -> (HappyAbsSyn ) -happyIn131 x = unsafeCoerce# x -{-# INLINE happyIn131 #-} -happyOut131 :: (HappyAbsSyn ) -> ([HsAlt]) -happyOut131 x = unsafeCoerce# x -{-# INLINE happyOut131 #-} -happyIn132 :: (HsAlt) -> (HappyAbsSyn ) -happyIn132 x = unsafeCoerce# x -{-# INLINE happyIn132 #-} -happyOut132 :: (HappyAbsSyn ) -> (HsAlt) -happyOut132 x = unsafeCoerce# x -{-# INLINE happyOut132 #-} -happyIn133 :: (HsGuardedAlts) -> (HappyAbsSyn ) -happyIn133 x = unsafeCoerce# x -{-# INLINE happyIn133 #-} -happyOut133 :: (HappyAbsSyn ) -> (HsGuardedAlts) -happyOut133 x = unsafeCoerce# x -{-# INLINE happyOut133 #-} -happyIn134 :: ([HsGuardedAlt]) -> (HappyAbsSyn ) -happyIn134 x = unsafeCoerce# x -{-# INLINE happyIn134 #-} -happyOut134 :: (HappyAbsSyn ) -> ([HsGuardedAlt]) -happyOut134 x = unsafeCoerce# x -{-# INLINE happyOut134 #-} -happyIn135 :: (HsGuardedAlt) -> (HappyAbsSyn ) -happyIn135 x = unsafeCoerce# x -{-# INLINE happyIn135 #-} -happyOut135 :: (HappyAbsSyn ) -> (HsGuardedAlt) -happyOut135 x = unsafeCoerce# x -{-# INLINE happyOut135 #-} -happyIn136 :: (HsPat) -> (HappyAbsSyn ) -happyIn136 x = unsafeCoerce# x -{-# INLINE happyIn136 #-} -happyOut136 :: (HappyAbsSyn ) -> (HsPat) -happyOut136 x = unsafeCoerce# x -{-# INLINE happyOut136 #-} -happyIn137 :: ([HsStmt]) -> (HappyAbsSyn ) -happyIn137 x = unsafeCoerce# x -{-# INLINE happyIn137 #-} -happyOut137 :: (HappyAbsSyn ) -> ([HsStmt]) -happyOut137 x = unsafeCoerce# x -{-# INLINE happyOut137 #-} -happyIn138 :: ([HsStmt]) -> (HappyAbsSyn ) -happyIn138 x = unsafeCoerce# x -{-# INLINE happyIn138 #-} -happyOut138 :: (HappyAbsSyn ) -> ([HsStmt]) -happyOut138 x = unsafeCoerce# x -{-# INLINE happyOut138 #-} -happyIn139 :: ([HsFieldUpdate]) -> (HappyAbsSyn ) -happyIn139 x = unsafeCoerce# x -{-# INLINE happyIn139 #-} -happyOut139 :: (HappyAbsSyn ) -> ([HsFieldUpdate]) -happyOut139 x = unsafeCoerce# x -{-# INLINE happyOut139 #-} -happyIn140 :: (HsFieldUpdate) -> (HappyAbsSyn ) -happyIn140 x = unsafeCoerce# x -{-# INLINE happyIn140 #-} -happyOut140 :: (HappyAbsSyn ) -> (HsFieldUpdate) -happyOut140 x = unsafeCoerce# x -{-# INLINE happyOut140 #-} -happyIn141 :: ([HsIPBind]) -> (HappyAbsSyn ) -happyIn141 x = unsafeCoerce# x -{-# INLINE happyIn141 #-} -happyOut141 :: (HappyAbsSyn ) -> ([HsIPBind]) -happyOut141 x = unsafeCoerce# x -{-# INLINE happyOut141 #-} -happyIn142 :: ([HsIPBind]) -> (HappyAbsSyn ) -happyIn142 x = unsafeCoerce# x -{-# INLINE happyIn142 #-} -happyOut142 :: (HappyAbsSyn ) -> ([HsIPBind]) -happyOut142 x = unsafeCoerce# x -{-# INLINE happyOut142 #-} -happyIn143 :: (HsIPBind) -> (HappyAbsSyn ) -happyIn143 x = unsafeCoerce# x -{-# INLINE happyIn143 #-} -happyOut143 :: (HappyAbsSyn ) -> (HsIPBind) -happyOut143 x = unsafeCoerce# x -{-# INLINE happyOut143 #-} -happyIn144 :: (HsExp) -> (HappyAbsSyn ) -happyIn144 x = unsafeCoerce# x -{-# INLINE happyIn144 #-} -happyOut144 :: (HappyAbsSyn ) -> (HsExp) -happyOut144 x = unsafeCoerce# x -{-# INLINE happyOut144 #-} -happyIn145 :: (HsName) -> (HappyAbsSyn ) -happyIn145 x = unsafeCoerce# x -{-# INLINE happyIn145 #-} -happyOut145 :: (HappyAbsSyn ) -> (HsName) -happyOut145 x = unsafeCoerce# x -{-# INLINE happyOut145 #-} -happyIn146 :: (HsName) -> (HappyAbsSyn ) -happyIn146 x = unsafeCoerce# x -{-# INLINE happyIn146 #-} -happyOut146 :: (HappyAbsSyn ) -> (HsName) -happyOut146 x = unsafeCoerce# x -{-# INLINE happyOut146 #-} -happyIn147 :: (HsQName) -> (HappyAbsSyn ) -happyIn147 x = unsafeCoerce# x -{-# INLINE happyIn147 #-} -happyOut147 :: (HappyAbsSyn ) -> (HsQName) -happyOut147 x = unsafeCoerce# x -{-# INLINE happyOut147 #-} -happyIn148 :: (HsIPName) -> (HappyAbsSyn ) -happyIn148 x = unsafeCoerce# x -{-# INLINE happyIn148 #-} -happyOut148 :: (HappyAbsSyn ) -> (HsIPName) -happyOut148 x = unsafeCoerce# x -{-# INLINE happyOut148 #-} -happyIn149 :: (HsName) -> (HappyAbsSyn ) -happyIn149 x = unsafeCoerce# x -{-# INLINE happyIn149 #-} -happyOut149 :: (HappyAbsSyn ) -> (HsName) -happyOut149 x = unsafeCoerce# x -{-# INLINE happyOut149 #-} -happyIn150 :: (HsQName) -> (HappyAbsSyn ) -happyIn150 x = unsafeCoerce# x -{-# INLINE happyIn150 #-} -happyOut150 :: (HappyAbsSyn ) -> (HsQName) -happyOut150 x = unsafeCoerce# x -{-# INLINE happyOut150 #-} -happyIn151 :: (HsName) -> (HappyAbsSyn ) -happyIn151 x = unsafeCoerce# x -{-# INLINE happyIn151 #-} -happyOut151 :: (HappyAbsSyn ) -> (HsName) -happyOut151 x = unsafeCoerce# x -{-# INLINE happyOut151 #-} -happyIn152 :: (HsQName) -> (HappyAbsSyn ) -happyIn152 x = unsafeCoerce# x -{-# INLINE happyIn152 #-} -happyOut152 :: (HappyAbsSyn ) -> (HsQName) -happyOut152 x = unsafeCoerce# x -{-# INLINE happyOut152 #-} -happyIn153 :: (HsQName) -> (HappyAbsSyn ) -happyIn153 x = unsafeCoerce# x -{-# INLINE happyIn153 #-} -happyOut153 :: (HappyAbsSyn ) -> (HsQName) -happyOut153 x = unsafeCoerce# x -{-# INLINE happyOut153 #-} -happyIn154 :: (HsName) -> (HappyAbsSyn ) -happyIn154 x = unsafeCoerce# x -{-# INLINE happyIn154 #-} -happyOut154 :: (HappyAbsSyn ) -> (HsName) -happyOut154 x = unsafeCoerce# x -{-# INLINE happyOut154 #-} -happyIn155 :: (HsQName) -> (HappyAbsSyn ) -happyIn155 x = unsafeCoerce# x -{-# INLINE happyIn155 #-} -happyOut155 :: (HappyAbsSyn ) -> (HsQName) -happyOut155 x = unsafeCoerce# x -{-# INLINE happyOut155 #-} -happyIn156 :: (HsOp) -> (HappyAbsSyn ) -happyIn156 x = unsafeCoerce# x -{-# INLINE happyIn156 #-} -happyOut156 :: (HappyAbsSyn ) -> (HsOp) -happyOut156 x = unsafeCoerce# x -{-# INLINE happyOut156 #-} -happyIn157 :: (HsQOp) -> (HappyAbsSyn ) -happyIn157 x = unsafeCoerce# x -{-# INLINE happyIn157 #-} -happyOut157 :: (HappyAbsSyn ) -> (HsQOp) -happyOut157 x = unsafeCoerce# x -{-# INLINE happyOut157 #-} -happyIn158 :: (HsQOp) -> (HappyAbsSyn ) -happyIn158 x = unsafeCoerce# x -{-# INLINE happyIn158 #-} -happyOut158 :: (HappyAbsSyn ) -> (HsQOp) -happyOut158 x = unsafeCoerce# x -{-# INLINE happyOut158 #-} -happyIn159 :: (HsQName) -> (HappyAbsSyn ) -happyIn159 x = unsafeCoerce# x -{-# INLINE happyIn159 #-} -happyOut159 :: (HappyAbsSyn ) -> (HsQName) -happyOut159 x = unsafeCoerce# x -{-# INLINE happyOut159 #-} -happyIn160 :: (HsQName) -> (HappyAbsSyn ) -happyIn160 x = unsafeCoerce# x -{-# INLINE happyIn160 #-} -happyOut160 :: (HappyAbsSyn ) -> (HsQName) -happyOut160 x = unsafeCoerce# x -{-# INLINE happyOut160 #-} -happyIn161 :: (HsName) -> (HappyAbsSyn ) -happyIn161 x = unsafeCoerce# x -{-# INLINE happyIn161 #-} -happyOut161 :: (HappyAbsSyn ) -> (HsName) -happyOut161 x = unsafeCoerce# x -{-# INLINE happyOut161 #-} -happyIn162 :: (HsName) -> (HappyAbsSyn ) -happyIn162 x = unsafeCoerce# x -{-# INLINE happyIn162 #-} -happyOut162 :: (HappyAbsSyn ) -> (HsName) -happyOut162 x = unsafeCoerce# x -{-# INLINE happyOut162 #-} -happyIn163 :: (HsIPName) -> (HappyAbsSyn ) -happyIn163 x = unsafeCoerce# x -{-# INLINE happyIn163 #-} -happyOut163 :: (HappyAbsSyn ) -> (HsIPName) -happyOut163 x = unsafeCoerce# x -{-# INLINE happyOut163 #-} -happyIn164 :: (HsQName) -> (HappyAbsSyn ) -happyIn164 x = unsafeCoerce# x -{-# INLINE happyIn164 #-} -happyOut164 :: (HappyAbsSyn ) -> (HsQName) -happyOut164 x = unsafeCoerce# x -{-# INLINE happyOut164 #-} -happyIn165 :: (HsName) -> (HappyAbsSyn ) -happyIn165 x = unsafeCoerce# x -{-# INLINE happyIn165 #-} -happyOut165 :: (HappyAbsSyn ) -> (HsName) -happyOut165 x = unsafeCoerce# x -{-# INLINE happyOut165 #-} -happyIn166 :: (HsQName) -> (HappyAbsSyn ) -happyIn166 x = unsafeCoerce# x -{-# INLINE happyIn166 #-} -happyOut166 :: (HappyAbsSyn ) -> (HsQName) -happyOut166 x = unsafeCoerce# x -{-# INLINE happyOut166 #-} -happyIn167 :: (HsName) -> (HappyAbsSyn ) -happyIn167 x = unsafeCoerce# x -{-# INLINE happyIn167 #-} -happyOut167 :: (HappyAbsSyn ) -> (HsName) -happyOut167 x = unsafeCoerce# x -{-# INLINE happyOut167 #-} -happyIn168 :: (HsQName) -> (HappyAbsSyn ) -happyIn168 x = unsafeCoerce# x -{-# INLINE happyIn168 #-} -happyOut168 :: (HappyAbsSyn ) -> (HsQName) -happyOut168 x = unsafeCoerce# x -{-# INLINE happyOut168 #-} -happyIn169 :: (HsQName) -> (HappyAbsSyn ) -happyIn169 x = unsafeCoerce# x -{-# INLINE happyIn169 #-} -happyOut169 :: (HappyAbsSyn ) -> (HsQName) -happyOut169 x = unsafeCoerce# x -{-# INLINE happyOut169 #-} -happyIn170 :: (HsName) -> (HappyAbsSyn ) -happyIn170 x = unsafeCoerce# x -{-# INLINE happyIn170 #-} -happyOut170 :: (HappyAbsSyn ) -> (HsName) -happyOut170 x = unsafeCoerce# x -{-# INLINE happyOut170 #-} -happyIn171 :: (HsName) -> (HappyAbsSyn ) -happyIn171 x = unsafeCoerce# x -{-# INLINE happyIn171 #-} -happyOut171 :: (HappyAbsSyn ) -> (HsName) -happyOut171 x = unsafeCoerce# x -{-# INLINE happyOut171 #-} -happyIn172 :: (HsQName) -> (HappyAbsSyn ) -happyIn172 x = unsafeCoerce# x -{-# INLINE happyIn172 #-} -happyOut172 :: (HappyAbsSyn ) -> (HsQName) -happyOut172 x = unsafeCoerce# x -{-# INLINE happyOut172 #-} -happyIn173 :: (HsLiteral) -> (HappyAbsSyn ) -happyIn173 x = unsafeCoerce# x -{-# INLINE happyIn173 #-} -happyOut173 :: (HappyAbsSyn ) -> (HsLiteral) -happyOut173 x = unsafeCoerce# x -{-# INLINE happyOut173 #-} -happyIn174 :: (SrcLoc) -> (HappyAbsSyn ) -happyIn174 x = unsafeCoerce# x -{-# INLINE happyIn174 #-} -happyOut174 :: (HappyAbsSyn ) -> (SrcLoc) -happyOut174 x = unsafeCoerce# x -{-# INLINE happyOut174 #-} -happyIn175 :: (()) -> (HappyAbsSyn ) -happyIn175 x = unsafeCoerce# x -{-# INLINE happyIn175 #-} -happyOut175 :: (HappyAbsSyn ) -> (()) -happyOut175 x = unsafeCoerce# x -{-# INLINE happyOut175 #-} -happyIn176 :: (()) -> (HappyAbsSyn ) -happyIn176 x = unsafeCoerce# x -{-# INLINE happyIn176 #-} -happyOut176 :: (HappyAbsSyn ) -> (()) -happyOut176 x = unsafeCoerce# x -{-# INLINE happyOut176 #-} -happyIn177 :: (Module) -> (HappyAbsSyn ) -happyIn177 x = unsafeCoerce# x -{-# INLINE happyIn177 #-} -happyOut177 :: (HappyAbsSyn ) -> (Module) -happyOut177 x = unsafeCoerce# x -{-# INLINE happyOut177 #-} -happyIn178 :: (HsName) -> (HappyAbsSyn ) -happyIn178 x = unsafeCoerce# x -{-# INLINE happyIn178 #-} -happyOut178 :: (HappyAbsSyn ) -> (HsName) -happyOut178 x = unsafeCoerce# x -{-# INLINE happyOut178 #-} -happyIn179 :: (HsQName) -> (HappyAbsSyn ) -happyIn179 x = unsafeCoerce# x -{-# INLINE happyIn179 #-} -happyOut179 :: (HappyAbsSyn ) -> (HsQName) -happyOut179 x = unsafeCoerce# x -{-# INLINE happyOut179 #-} -happyIn180 :: (HsQName) -> (HappyAbsSyn ) -happyIn180 x = unsafeCoerce# x -{-# INLINE happyIn180 #-} -happyOut180 :: (HappyAbsSyn ) -> (HsQName) -happyOut180 x = unsafeCoerce# x -{-# INLINE happyOut180 #-} -happyIn181 :: (HsName) -> (HappyAbsSyn ) -happyIn181 x = unsafeCoerce# x -{-# INLINE happyIn181 #-} -happyOut181 :: (HappyAbsSyn ) -> (HsName) -happyOut181 x = unsafeCoerce# x -{-# INLINE happyOut181 #-} -happyIn182 :: (HsQName) -> (HappyAbsSyn ) -happyIn182 x = unsafeCoerce# x -{-# INLINE happyIn182 #-} -happyOut182 :: (HappyAbsSyn ) -> (HsQName) -happyOut182 x = unsafeCoerce# x -{-# INLINE happyOut182 #-} -happyIn183 :: (HsName) -> (HappyAbsSyn ) -happyIn183 x = unsafeCoerce# x -{-# INLINE happyIn183 #-} -happyOut183 :: (HappyAbsSyn ) -> (HsName) -happyOut183 x = unsafeCoerce# x -{-# INLINE happyOut183 #-} -happyInTok :: Token -> (HappyAbsSyn ) -happyInTok x = unsafeCoerce# x -{-# INLINE happyInTok #-} -happyOutTok :: (HappyAbsSyn ) -> Token -happyOutTok x = unsafeCoerce# x -{-# INLINE happyOutTok #-} - - -happyActOffsets :: HappyAddr -happyActOffsets = HappyA# "\x2e\x06\x00\x00\x00\x00\x29\x06\xfc\x05\x00\x00\x9e\x00\x00\x00\x1a\x06\x2b\x00\x00\x00\x00\x00\x00\x00\x1c\x01\xda\x04\x45\x06\x00\x00\x00\x00\x00\x00\x35\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x06\x00\x00\xc8\x05\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\x00\x00\x00\xee\x06\x00\x00\x00\x00\x1c\x01\xf0\x14\xf1\x05\x00\x00\x76\x19\x3e\x06\x34\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x06\x00\x00\x00\x00\x00\x00\x00\x00\x91\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x04\x00\x00\x2c\x06\x00\x00\x2b\x06\x00\x00\x00\x00\x22\x06\x00\x00\x87\x04\x00\x00\xa5\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x06\x67\x03\x00\x00\x00\x00\x52\x03\x00\x00\x00\x00\x00\x00\x00\x00\x66\x05\x56\x0d\x00\x00\x26\x16\x6f\x13\x00\x00\x6f\x13\x6f\x13\x6f\x13\x7d\x18\x00\x00\x49\x1a\x25\x1a\x6f\x13\x00\x00\x33\x06\x98\x17\xd2\x02\x60\x14\x00\x00\xde\x15\x00\x00\x00\x00\xab\x03\x00\x00\x26\x16\x6f\x13\x5d\x01\x6f\x13\x7d\x18\xee\x05\x2d\x06\xe3\x05\x26\x06\xd2\x05\x00\x00\x00\x00\x00\x00\x7d\x18\x20\x06\x00\x00\x5c\x18\x8c\x06\x1f\x06\x2a\x06\x1f\x06\x00\x00\x00\x00\x00\x00\x00\x00\x50\x07\x08\x06\xd1\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x17\xf8\x04\x35\x18\xf8\x04\xd6\x19\x00\x00\xf4\x0c\xf4\x0c\x00\x00\x00\x00\x6e\x16\xd1\x05\xfe\x05\x07\x06\x00\x00\xbc\x04\x00\x00\x00\x00\x14\x18\xf8\x04\x14\x18\x01\x06\xc4\x05\x00\x00\x00\x00\x9a\x10\x00\x00\x00\x00\x6f\x13\x06\x06\x63\x04\x63\x04\x0c\x06\xde\x15\x26\x16\x26\x16\x00\x00\x9c\x05\xf6\x05\x00\x00\x00\x00\x00\x00\x3b\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x05\x00\x00\x00\x00\x00\x00\x00\x00\x72\x15\x00\x00\x00\x00\x6f\x13\x00\x00\x00\x00\x00\x00\x83\x0a\x14\x18\x39\x01\x14\x18\x4f\x02\x00\x00\xd9\x05\x00\x00\x00\x00\x1d\x01\xef\x05\x00\x00\x00\x00\x3a\x05\x00\x00\xcf\x05\xcd\x05\xe4\x04\xcb\x05\xe5\x05\xe4\x05\x27\x01\x00\x00\xf6\x01\xda\x05\xbf\x05\x00\x00\x29\x01\xff\x02\xda\x02\xe1\x05\x00\x00\x00\x00\x6f\x13\xdf\x05\xdd\x05\x00\x00\x00\x00\xdc\x05\xdb\x05\x00\x00\x00\x00\x72\x15\xd3\x05\xde\x15\xca\x05\xc9\x05\x1c\x01\x00\x00\x00\x00\x26\x16\x99\x08\x00\x00\x00\x00\x01\x1a\xc1\x05\x9b\x19\x00\x00\x00\x00\x00\x00\x53\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\xb6\x05\x01\x02\x00\x00\xb0\x05\x00\x00\x00\x00\xf2\x04\x00\x00\xaa\x05\xa9\x05\x00\x00\x00\x00\xb3\x05\x00\x00\x00\x00\x6f\x13\x00\x00\x00\x00\x00\x00\x6f\x13\x6f\x13\x6f\x13\x00\x00\x6f\x13\x92\x0c\x0d\x13\xab\x12\x00\x00\x49\x12\x00\x00\x00\x00\xca\x13\x00\x00\x00\x00\x2e\x00\xb2\x05\x00\x00\x3c\x02\x00\x00\xac\x05\x00\x00\xa5\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x07\x39\x01\x75\x05\x5b\x05\x34\x01\x00\x00\x00\x00\x00\x00\xab\x02\x00\x00\xa2\x05\x49\x12\x00\x00\x00\x00\x00\x00\xa6\x05\x00\x00\x00\x00\xb2\x07\x60\x03\x00\x00\x00\x00\xa2\x04\x00\x00\x65\x05\x00\x00\x00\x00\x58\x05\x26\x16\xe7\x11\x00\x00\xa1\x05\x54\x05\x00\x00\x92\x05\xa0\x05\x96\x05\x00\x00\x8d\x05\x00\x00\x5e\x05\xe5\x0a\x87\x19\xf8\x04\x00\x00\x8b\x05\x00\x00\x87\x19\x00\x00\x87\x19\x00\x00\x00\x00\x01\x16\x87\x19\x87\x19\x8f\x05\x95\x02\x00\x00\x8c\x05\x30\x0c\x8a\x05\x2e\x00\x7a\x05\x7e\x05\x7b\x05\x00\x00\xa3\x02\x79\x05\xa8\x01\x7d\x05\x87\x19\x14\x18\x00\x00\x87\x19\x00\x00\x00\x00\x34\x01\x00\x00\xf8\x04\x00\x00\x00\x00\x14\x18\x00\x00\x77\x00\x00\x00\x00\x00\x67\x05\xe4\x09\x3c\x19\x00\x00\x6e\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x06\x14\x18\x25\x00\x8d\x04\xf8\x04\x00\x00\x00\x00\x66\x16\x72\x05\x00\x00\x00\x00\x74\x05\x00\x00\x00\x00\x00\x00\x14\x18\x00\x00\x96\x15\x00\x00\x00\x00\x8c\x11\x82\x09\x71\x05\x70\x05\x2e\x00\x2e\x00\x8c\x11\x00\x00\x64\x05\x00\x00\xb9\x0e\xab\x02\xa2\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x05\x48\x05\x00\x00\x00\x00\x6a\x05\x00\x00\x4d\x05\x35\x05\x00\x00\x03\x05\x00\x00\x2a\x05\x34\x01\x00\x00\x00\x00\x37\x05\x00\x00\xc7\x02\xfb\x04\xea\x04\x2b\x05\x25\x05\x4f\x02\x00\x00\x00\x00\x11\x05\x07\x05\x00\x00\x00\x00\x00\x00\x15\x05\x00\x00\x0d\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x14\x00\x00\x00\x00\x00\x00\x1c\x01\x8c\x11\x8c\x11\x00\x00\x5d\x09\x00\x00\x1d\x05\x00\x00\x70\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xf3\x04\x2d\x04\xce\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x05\x00\x00\x00\x00\x00\x00\x0d\x02\x00\x00\x00\x00\x00\x00\x0c\x05\x34\x01\x1b\x19\x00\x00\x00\x00\x00\x00\xd4\x04\xfc\x04\x2a\x11\xc8\x10\x00\x00\x0b\x05\xf9\x04\x87\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x10\xc7\x04\x00\x00\x04\x10\x00\x00\xff\x04\xf6\x04\x2e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x04\x00\x00\x00\x00\x00\x00\xf7\x04\x00\x00\x00\x00\xe2\x04\x20\x09\xe9\x04\x2e\x00\x00\x00\x00\x00\x04\x10\x6c\x0b\x00\x00\x00\x00\xe7\x04\x00\x00\x00\x00\xe6\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x0f\x34\x01\x5f\x1a\x05\x06\x00\x00\xfa\x07\xdb\x04\x2e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x14\x00\x00\x40\x0f\xd6\x04\x57\x04\xd3\x04\x0a\x0b\xd3\x04\x00\x00\x87\x19\x00\x00\x00\x00\x00\x00\x40\x0f\x00\x00\xfb\x08\x2f\x17\xc8\x04\x00\x00\x00\x00\x14\x19\x1f\x00\xd0\x04\xc4\x04\xb9\x16\x87\x19\x00\x00\x00\x00\xc0\x04\xb4\x04\x2e\x00\x29\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x03\x00\x00\x5f\x04\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x02\x00\x00\x37\x08\xcc\x18\xc2\x04\x00\x00\x00\x00\x87\x19\xc5\x18\x87\x19\x87\x19\x00\x00\x00\x00\x00\x00\x00\x00\xde\x0e\x00\x00\x46\x04\x7c\x0e\x00\x00\xe4\x04\xaa\x04\x2c\x14\xab\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x08\xa8\x04\xa1\x04\x00\x00\x00\x00\x00\x00\xa5\x04\x9f\x04\x14\x18\x00\x00\x87\x19\xa8\x0a\x90\x04\x46\x0a\x00\x00\x00\x00\x7d\x04\x39\x01\x00\x00\xea\x19\x85\x04\xe7\x16\x00\x00\x14\x18\xf8\x04\x5c\x08\x80\x04\x00\x00\x23\x04\x6d\x04\x00\x00\x5d\x04\x7c\x0e\x00\x00\x69\x04\x00\x00\x87\x19\x0d\x18\x00\x00\x00\x00\x87\x19\x00\x00\x66\x02\xc2\x01\x00\x00\x00\x00\x00\x00\x5e\x04\x23\x02\x62\x02\x67\x04\x00\x00\x1c\x01\x3c\x04\x00\x00\xbf\x17\x00\x00\xa3\x05\x77\x17\x00\x00\x1a\x0e\x00\x00\x00\x00\x00\x00\x54\x04\x50\x04\x50\x04\x00\x00\x00\x00\xd8\x01\x00\x00\x61\x04\x20\x04\xff\x03\xbf\x17\x00\x00\x3f\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x17\x28\x04\x00\x00\x00\x00\x87\x19\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x0d\x00\x00\x00\x00\x00\x00\x00\x00"# - -happyGotoOffsets :: HappyAddr -happyGotoOffsets = HappyA# "\x01\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x08\x00\x00\x00\x06\x00\x00\x00\x57\x03\x08\x03\xd4\x03\xa3\x03\x3b\x04\x00\x00\x00\x00\xc5\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x7e\x03\x75\x03\x03\x00\x00\x00\x00\x00\x00\x00\x36\x04\x00\x00\x00\x00\x00\x00\x31\x04\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\xaa\x03\x57\x24\x00\x00\x00\x00\x07\x00\x00\x00\x0a\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x03\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x1a\x92\x1d\x00\x00\xeb\x24\x0d\x1e\x00\x00\xc4\x22\x81\x22\x23\x23\x36\x03\x66\x03\x41\x05\x64\x00\x65\x22\x00\x00\xf3\x03\x16\x03\x00\x00\x6c\x06\x00\x00\xd5\x24\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x23\x22\x22\x00\x00\x06\x22\x01\x03\x00\x00\x00\x00\x00\x00\x73\x00\xf7\x03\x00\x00\x00\x00\x00\x00\xd8\x02\x4e\x00\x00\x00\xee\x03\x39\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\xfa\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x01\xf7\x02\x93\x03\x8e\x03\xe8\x03\x00\x00\x4f\x1d\x0c\x1d\x00\x00\x00\x00\xfa\x03\xa4\x03\x00\x00\x00\x00\xb8\x03\x45\x03\x00\x00\x00\x00\xb9\x02\x3b\x00\xae\x02\x9b\x03\x00\x00\x00\x00\x00\x00\x58\x0f\x00\x00\x1a\x03\xc3\x21\x3c\x00\x8a\x03\x86\x03\x00\x00\xd5\x24\xbf\x24\x83\x24\x00\x00\x54\x03\xc2\xff\x00\x00\x00\x00\x00\x00\x77\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x04\x00\x00\x00\x00\xa7\x21\x00\x00\x00\x00\x00\x00\x56\x01\x99\x02\x1b\x02\x7f\x02\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x03\x00\x00\x00\x00\x00\x00\xea\x02\x27\x00\x00\x00\x00\x00\x20\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x04\x00\x00\x8d\x23\x00\x00\x00\x00\xaf\x03\x23\x03\x00\x00\x6d\x24\x0f\x01\x00\x00\x00\x00\x55\x00\x00\x00\xfb\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x01\x33\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x21\x00\x00\x00\x00\x00\x00\x48\x21\xf1\x1d\x05\x21\x00\x00\xe9\x20\xa6\x20\x7a\x1b\x8a\x20\x00\x00\x37\x1b\x00\x00\x00\x00\x06\x19\x00\x00\x00\x00\xe3\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x02\xc7\x01\x1f\x03\x00\x00\xb1\x03\x7c\x00\x00\x00\x00\x00\xad\x02\x00\x00\x00\x00\xf4\x1a\x00\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x28\x03\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\xe3\x00\x6e\x00\x00\x00\xc9\x23\x06\x19\x9e\x02\xaa\xff\xf6\x02\x4b\x02\xf1\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x03\xd8\xff\xdc\x03\x6f\x03\x00\x00\x70\x02\x00\x00\xd6\x03\x00\x00\xce\x03\x00\x00\x00\x00\xb4\x02\xb5\x03\x55\x04\x00\x00\xce\x06\x49\x02\x00\x00\xc9\x1c\xf7\xff\x43\x02\x00\x00\x34\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x04\x77\x02\x00\x00\xb5\x04\x00\x00\x00\x00\x9e\x03\x00\x00\x56\x03\x00\x00\x00\x00\x60\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x1c\xb5\x04\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x2b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x01\x31\x02\xe6\x01\xb3\x01\x50\x03\x00\x00\x00\x00\x7f\x01\x00\x00\x00\x00\x00\x00\xd9\xff\x00\x00\x37\x00\x0e\x00\xf5\x01\x00\x00\xdf\x23\x00\x00\x00\x00\x47\x20\x15\x00\x00\x00\x00\x00\xf0\x01\xbe\x01\x2b\x20\x00\x00\x00\x00\x00\x00\xe1\x00\xa6\x01\xf8\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x01\xf2\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x9c\x03\x00\x00\x00\x00\x49\x00\x00\x00\x6a\x02\x84\x01\x00\x00\x00\x00\x00\x00\xa2\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\x1b\x24\x00\x00\x00\x00\x00\x00\x72\x03\xae\x1d\xe8\x1f\x00\x00\x59\x02\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x3a\x01\x74\x00\x00\x00\x91\x03\x74\x04\xe2\x01\x23\x00\x00\x00\x00\x00\x00\x00\x43\x1c\x89\x1f\x00\x00\x00\x00\x00\x00\xae\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x03\x00\x00\xbd\x03\x00\x00\xf3\x00\x00\x00\x00\x00\x6d\x1f\x00\x00\x67\x01\x00\x00\x2f\x01\x00\x00\x23\x01\x16\x01\x61\x02\x00\x00\x6d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x00\x00\x00\xdf\x00\x00\x00\x00\x00\x2a\x1f\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x03\x00\x00\x00\x00\x00\x00\x09\x01\xe7\x02\x1c\x00\x7f\x01\x00\x00\xf4\xff\x00\x00\xca\x00\x00\x00\x00\x00\x21\x03\x00\x00\x39\x23\x00\x00\x0e\x1f\x00\x00\x97\xff\x00\x00\x40\x00\x00\x00\x00\x00\xa0\x03\x00\x00\x00\x00\x00\x00\xcb\x1e\x00\x00\xd8\xff\xb5\x04\x00\x00\x00\x00\x00\x00\xb0\x00\xbd\xff\x00\x00\x00\x00\x8a\x01\xb0\x04\x00\x00\x00\x00\x35\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x33\x01\x00\x00\xe8\x01\x00\x00\x00\x00\x0d\x03\x00\x00\x31\x01\x00\x00\x88\x03\x2b\x04\x84\x00\x00\x00\x00\x00\x98\x04\x7a\x04\x30\x04\x86\x04\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\xee\xff\xaf\x1e\x00\x00\x0a\x06\x6e\x01\xb4\xff\x00\x00\x00\x00\x00\x00\x00\x00\x63\x01\x00\x00\x00\x00\xa9\x00\x00\x00\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x01\x00\x00\x4d\x01\xe4\x00\x00\x00\xbd\x1b\x00\x00\x00\x00\x00\x00\x22\x01\x00\x00\x43\x00\x00\x00\xf3\xff\x00\x00\xd6\x01\xce\x02\x28\x00\x00\x00\x00\x00\x8a\x00\xa7\xff\x00\x00\x00\x00\x6c\x1e\x00\x00\x00\x00\x00\x00\x81\x04\x81\x04\x00\x00\x00\x00\x81\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x02\xde\xff\x00\x00\x00\x00\x3c\x01\x00\x00\x00\x00\xb4\x01\x00\x00\xc7\x00\x9f\x01\x00\x00\xb1\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\xff\x00\x00\xa9\x01\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x00\x00\x00\x00\x00\x00\x3a\x04\x00\x00\x00\x00\x00\x00\x00\x00\x50\x1e\x00\x00\x00\x00\x00\x00\x00\x00"# - -happyDefActions :: HappyAddr -happyDefActions = HappyA# "\x57\xfe\x00\x00\xfe\xff\x00\x00\x00\x00\xfc\xff\x56\xfe\x57\xfe\x00\x00\x56\xfe\xf8\xff\xef\xff\xef\xff\x00\x00\x00\x00\xed\xff\x53\xfe\x52\xfe\xce\xfe\xd5\xfe\xd4\xfe\xd3\xfe\xd2\xfe\xd0\xfe\xd1\xfe\x00\x00\xf0\xff\xf2\xff\x00\x00\x57\xfe\x57\xfe\xf6\xff\x54\xfe\x55\xfe\xef\xff\xdf\xff\xa3\xff\xf4\xff\xef\xff\xbe\xff\xae\xff\xa4\xff\xa2\xff\x57\xfe\xf1\xff\xf7\xff\x00\x00\x57\xfe\x00\x00\xee\xff\xe9\xff\x00\x00\xe9\xff\xe7\xff\xe6\xff\x97\xfe\x75\xfe\x7e\xfe\x50\xfe\x6f\xfe\xe5\xff\x7c\xfe\x7d\xfe\x6d\xfe\x6e\xfe\x00\x00\xea\xff\x78\xfe\x74\xfe\x73\xfe\x72\xfe\x77\xfe\x76\xfe\x7b\xfe\x79\xfe\x00\x00\x7a\xfe\x56\xfe\xcc\xfe\x01\xff\xfe\xfe\xf1\xfe\x00\x00\xcf\xfe\x00\x00\xfb\xfe\xfc\xfe\xfd\xfe\x9c\xfe\x95\xfe\x92\xfe\xfa\xfe\x00\x00\x7c\xfe\x71\xfe\x70\xfe\x6d\xfe\x5b\xfe\x59\xfe\x5a\xfe\x58\xfe\x57\xfe\x57\xfe\xf5\xfe\x57\xfe\x57\xfe\xf0\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x56\xfe\x00\x00\x00\x00\x57\xfe\xd6\xfe\xc7\xff\x00\x00\x00\x00\x57\xfe\x12\xff\x0a\xff\x08\xff\x13\xff\xfc\xfe\xca\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\xad\xff\x00\x00\x00\x00\x56\xfe\xdc\xff\xc5\xff\xc4\xff\xc3\xff\x00\x00\x56\xfe\xac\xff\x00\x00\xf0\xff\xc0\xff\xf0\xff\xf3\xff\xfd\xff\xe0\xff\xf5\xff\xbf\xff\x57\xfe\x00\x00\x91\xff\x89\xff\x88\xff\x4e\xfe\x81\xff\x87\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\xff\x57\xfe\x57\xfe\x8b\xff\x79\xff\x91\xff\x2d\xff\x00\x00\x00\x00\x72\xff\x00\x00\xdd\xff\x0c\xff\x00\x00\xa9\xff\x00\x00\x6d\xff\x00\x00\x1a\xff\x18\xff\x17\xff\x15\xff\x57\xfe\x57\xfe\x56\xfe\x00\x00\x00\x00\x00\x00\x0d\xff\x57\xfe\x57\xfe\x09\xff\x21\xff\x1f\xff\x1d\xff\x84\xfe\x83\xfe\x57\xfe\x88\xfe\x7f\xfe\x6c\xfe\x8e\xfe\x69\xfe\x68\xfe\x00\x00\x65\xfe\x6a\xfe\x5c\xfe\x6b\xfe\x00\x00\x62\xfe\x80\xfe\x57\xfe\x64\xfe\x63\xfe\x61\xfe\x00\x00\x00\x00\x62\xff\x00\x00\x00\x00\xc6\xff\x00\x00\xe7\xfe\xe8\xfe\x00\x00\x00\x00\xea\xfe\xe9\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x17\xff\x00\x00\x00\x00\xe1\xfe\x00\x00\x02\xff\xc9\xfe\x00\x00\xc8\xfe\x9e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x82\xfe\x81\xfe\x57\xfe\x88\xfe\x00\x00\x8c\xfe\x67\xfe\x66\xfe\x60\xfe\x9f\xfe\xe5\xfe\x00\x00\x5e\xfe\x64\xfe\x5f\xfe\x5d\xfe\x00\x00\xda\xfe\xfa\xff\x57\xfe\x00\x00\xf9\xff\xe1\xff\x00\x00\x00\x00\xea\xff\xeb\xff\xe8\xff\xec\xff\x00\x00\xcb\xff\xca\xff\xc9\xff\x9b\xfe\x94\xfe\x00\x00\xe3\xff\x00\x00\x00\x00\xa5\xfe\x00\x00\x00\xff\xcd\xfe\x57\xfe\xce\xfe\x00\x00\x00\x00\x96\xfe\x91\xfe\x00\x00\xf4\xfe\xf8\xfe\x57\xfe\x9d\xfe\xe6\xfe\xf9\xfe\x57\xfe\x57\xfe\x57\xfe\xf7\xfe\x57\xfe\xc7\xfe\x57\xfe\x57\xfe\xf3\xfe\x57\xfe\xef\xfe\xee\xfe\x57\xfe\xed\xfe\xec\xfe\x00\x00\x00\x00\x7e\xff\x00\x00\x80\xff\x00\x00\xdc\xfe\xc8\xff\x86\xfe\x85\xfe\xc1\xff\x8a\xfe\x90\xfe\x00\x00\x62\xff\x49\xff\x00\x00\x00\x00\x57\xfe\x9f\xff\x9b\xff\x00\x00\x20\xff\x00\x00\x57\xfe\x14\xff\x1e\xff\x23\xff\x56\xfe\x03\xff\x04\xff\xb1\xff\x94\xff\x99\xff\x98\xff\x00\x00\x9e\xff\x00\x00\xef\xff\xef\xff\x00\x00\x57\xfe\x19\xff\x57\xfe\x56\xfe\x3b\xff\x6e\xff\x3e\xff\x00\x00\xaa\xff\xab\xff\x00\x00\xb3\xff\xda\xff\x00\x00\x00\x00\x00\x00\xb4\xff\x56\xfe\x8a\xff\x00\x00\x7c\xff\x00\x00\x4c\xfe\x4b\xfe\x00\x00\x00\x00\x00\x00\xa7\xfe\x17\xff\x57\xfe\x00\x00\x57\xfe\x56\xfe\x00\x00\x00\x00\x3e\xff\x00\x00\x75\xff\x00\x00\x79\xff\x00\x00\x00\x00\x00\x00\x00\x00\xbd\xff\x8d\xff\x86\xff\x83\xff\x00\x00\x85\xff\x00\x00\x84\xff\xbc\xff\x00\x00\xad\xfe\x00\x00\xa9\xfe\xae\xfe\x00\x00\xa8\xfe\x8d\xff\x8e\xff\x00\x00\x8f\xff\x90\xff\xef\xff\xef\xff\x7a\xff\x8c\xff\x73\xff\x71\xff\x00\x00\x00\x00\xd8\xff\x00\x00\x00\x00\xb2\xff\xb8\xff\x00\x00\x6c\xff\x6a\xff\xb5\xff\x56\xfe\x0e\xff\xef\xff\xef\xff\x00\x00\x16\xff\x57\xfe\x06\xff\x05\xff\x57\xfe\xa7\xff\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\xaf\xff\x00\x00\x99\xfe\x00\x00\x00\x00\x00\x00\x97\xff\x96\xff\x95\xff\x22\xff\xbc\xfe\x00\x00\xc0\xfe\xbe\xfe\x57\xfe\x56\xfe\x8d\xfe\x00\x00\x61\xff\x5f\xff\x5b\xff\x3d\xff\x43\xff\x00\x00\x40\xff\x41\xff\x56\xfe\xba\xff\x00\x00\x49\xff\x00\x00\x00\x00\x00\x00\x00\x00\x7f\xff\x7d\xff\x00\x00\x00\x00\xe2\xfe\xc3\xfe\xc5\xfe\xc1\xfe\xc2\xfe\xdf\xfe\xe0\xfe\xe3\xfe\xe4\xfe\xf6\xfe\x87\xfe\x8b\xfe\x57\xfe\xd7\xfe\xdb\xfe\xd9\xfe\x00\x00\x57\xfe\x57\xfe\xff\xfe\x00\x00\xe4\xff\x00\x00\xe2\xff\x00\x00\xcc\xff\x93\xfe\xa6\xfe\xa4\xfe\xe1\xfe\x00\x00\x00\x00\x00\x00\xc6\xfe\xf2\xfe\xeb\xfe\xc2\xff\x89\xfe\x8f\xfe\x56\xfe\xb7\xff\x4f\xfe\x48\xff\x00\x00\xb9\xff\xef\xff\xef\xff\x00\x00\x00\x00\x00\x00\x72\xff\x57\xfe\x9a\xfe\xbb\xfe\x00\x00\x57\xfe\x57\xfe\xb0\xff\x00\x00\x00\x00\x00\x00\x10\xff\x9c\xff\xa0\xff\x9d\xff\xa1\xff\xef\xff\xa5\xff\xef\xff\xa1\xfe\x57\xfe\x00\x00\x07\xff\x57\xfe\x1b\xff\x57\xfe\x00\x00\x00\x00\x3c\xff\xef\xff\xef\xff\x6e\xff\x6f\xff\x6e\xff\x76\xff\xdb\xff\xde\xff\xd9\xff\x00\x00\xd5\xff\x7b\xff\x00\x00\x2b\xff\x00\x00\x00\x00\x4d\xfe\xaa\xfe\x57\xfe\x57\xfe\xbb\xff\x74\xff\x00\x00\x82\xff\xac\xfe\x00\x00\x2e\xff\x2f\xff\xef\xff\x29\xff\x27\xff\x28\xff\x57\xfe\x00\x00\xe9\xff\x69\xff\x6b\xff\x37\xff\x00\x00\x00\x00\xb9\xfe\xba\xfe\xef\xff\xb6\xfe\x57\xfe\x11\xff\x57\xfe\xfd\xfe\xf0\xff\xa3\xfe\xf0\xff\xa8\xff\x92\xff\x00\x00\x98\xfe\x1c\xff\xbf\xfe\x57\xfe\x60\xff\x00\x00\x56\xff\x00\x00\x5d\xff\x5a\xff\x55\xff\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x42\xff\x3f\xff\x57\xfe\x00\x00\x00\x00\x00\x00\x44\xff\x47\xff\xb6\xff\xc4\xfe\xda\xfe\xdd\xfe\xfb\xff\xd8\xfe\x57\xfe\x46\xff\x00\x00\x67\xff\x68\xff\xef\xff\x64\xff\x00\x00\x4f\xff\x00\x00\x00\x00\x00\x00\x52\xff\x53\xff\x00\x00\x00\x00\x00\x00\x00\x00\x5c\xff\xbd\xfe\x93\xff\xa6\xff\x57\xfe\xa2\xfe\x00\x00\x57\xfe\x0f\xff\xaf\xfe\x57\xfe\xf0\xff\xb8\xfe\x39\xff\x3a\xff\x34\xff\xef\xff\x35\xff\x33\xff\x57\xfe\x00\x00\xe9\xff\xd2\xff\xd1\xff\x51\xfe\xd0\xff\x00\x00\x00\x00\xad\xff\x00\x00\xf0\xff\x2c\xff\x57\xfe\xab\xfe\x2a\xff\x00\x00\x62\xff\x70\xff\x00\x00\x00\x00\xea\xff\xd6\xff\x00\x00\x00\x00\xf0\xff\x38\xff\xb7\xfe\x21\xff\xb3\xfe\xb1\xfe\x00\x00\x57\xfe\xa0\xfe\x00\x00\x54\xff\x77\xff\x56\xff\x5e\xff\x51\xff\x50\xff\x59\xff\x00\x00\x00\x00\x4d\xff\x9a\xff\x58\xff\x00\x00\x00\x00\xf0\xff\x66\xff\x45\xff\x00\x00\x00\x00\x65\xff\x00\x00\x57\xff\x00\x00\x00\x00\xb4\xfe\x57\xfe\xb2\xfe\xb5\xfe\x36\xff\x8b\xff\x3e\xff\x3e\xff\xd3\xff\xd7\xff\x00\x00\xce\xff\x00\x00\x49\xff\x00\x00\x00\x00\x26\xff\x56\xfe\x25\xff\xcf\xff\xcd\xff\x30\xff\x32\xff\x00\x00\x00\x00\x4b\xff\x4c\xff\x00\x00\x4e\xff\x63\xff\xde\xfe\x4a\xff\x57\xfe\x31\xff\x24\xff\xb0\xfe"# - -happyCheck :: HappyAddr -happyCheck = HappyA# "\xff\xff\x00\x00\x01\x00\x02\x00\x01\x00\x01\x00\x0b\x00\x14\x00\x03\x00\x03\x00\x02\x00\x17\x00\x03\x00\x35\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x05\x00\x06\x00\x23\x00\x22\x00\x25\x00\x24\x00\x17\x00\x23\x00\x3d\x00\x25\x00\x1b\x00\x1c\x00\x1d\x00\x5e\x00\x29\x00\x8b\x00\x0d\x00\x22\x00\x09\x00\x24\x00\x7d\x00\x09\x00\x50\x00\x83\x00\x4a\x00\x17\x00\x17\x00\x00\x00\x13\x00\x14\x00\x1b\x00\x1c\x00\x1d\x00\x80\x00\x10\x00\x21\x00\x22\x00\x22\x00\x24\x00\x24\x00\x1c\x00\x05\x00\x06\x00\x17\x00\x17\x00\x15\x00\xaa\x00\x1b\x00\x1c\x00\x1d\x00\x17\x00\x52\x00\x53\x00\x54\x00\x22\x00\x22\x00\x24\x00\x24\x00\x23\x00\x5a\x00\x25\x00\x17\x00\xaa\x00\x29\x00\x96\x00\x3a\x00\xab\x00\x1d\x00\x17\x00\x15\x00\x16\x00\x1f\x00\x22\x00\x5a\x00\x24\x00\xaa\x00\x23\x00\xa3\x00\x25\x00\x22\x00\x40\x00\x24\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x15\x00\x16\x00\xaa\x00\x32\x00\x33\x00\x5a\x00\x5a\x00\x3c\x00\x3d\x00\x05\x00\x06\x00\x9d\x00\x9e\x00\x52\x00\x19\x00\x05\x00\x06\x00\x53\x00\x54\x00\x1e\x00\x90\x00\x3a\x00\x8d\x00\x5a\x00\x5a\x00\x3a\x00\xab\x00\x26\x00\x8e\x00\x5c\x00\xaa\x00\xb1\x00\x8f\x00\x14\x00\x7e\x00\x9f\x00\x20\x00\x16\x00\x9d\x00\x9e\x00\x2e\x00\x5a\x00\xa1\x00\x9d\x00\x8f\x00\x9c\x00\x9d\x00\x9e\x00\x5a\x00\xa0\x00\xa1\x00\xab\x00\xaa\x00\x8a\x00\x8b\x00\xae\x00\xab\x00\x9c\x00\x9d\x00\x9e\x00\x1a\x00\xa0\x00\xa1\x00\x8d\x00\xaf\x00\xaa\x00\xaa\x00\xaa\x00\xaa\x00\x3b\x00\xab\x00\xab\x00\xaa\x00\x15\x00\xab\x00\x7e\x00\xaf\x00\x8e\x00\x4e\x00\x9d\x00\x9e\x00\x3f\x00\x40\x00\xa1\x00\x4e\x00\xaa\x00\xaa\x00\x62\x00\x19\x00\x64\x00\x65\x00\xab\x00\x9d\x00\x68\x00\x69\x00\x6a\x00\xae\x00\x90\x00\x55\x00\xaa\x00\x6f\x00\x26\x00\x8d\x00\xaa\x00\xaa\x00\x85\x00\x91\x00\xab\x00\x77\x00\x39\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2d\x00\x2e\x00\xaa\x00\x9d\x00\x9e\x00\x8d\x00\xaa\x00\xa1\x00\x5b\x00\x91\x00\xab\x00\x05\x00\x06\x00\xaa\x00\x8c\x00\xb1\x00\x26\x00\x8f\x00\x90\x00\xab\x00\x92\x00\x9d\x00\x9e\x00\xab\x00\x45\x00\xa1\x00\x89\x00\x85\x00\xab\x00\x5c\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x20\x00\xa0\x00\xa1\x00\x8d\x00\x09\x00\xa9\x00\xaa\x00\x91\x00\x62\x00\x19\x00\x64\x00\x65\x00\x48\x00\x1a\x00\x68\x00\x69\x00\x6a\x00\x70\x00\xb1\x00\x9d\x00\x9e\x00\x6f\x00\x26\x00\xa1\x00\x05\x00\x06\x00\x01\x00\xab\x00\x93\x00\x77\x00\x05\x00\x96\x00\x07\x00\x98\x00\xa1\x00\xaa\x00\x1e\x00\x05\x00\x06\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x11\x00\xa3\x00\x05\x00\x06\x00\xa6\x00\x05\x00\x06\x00\x8c\x00\x40\x00\x1a\x00\x8f\x00\x90\x00\x11\x00\x92\x00\x58\x00\x59\x00\x5a\x00\x05\x00\x06\x00\x1a\x00\x25\x00\x1a\x00\x10\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x4b\x00\x23\x00\x9d\x00\x9e\x00\xac\x00\xa0\x00\xa1\x00\xa9\x00\xaa\x00\x2d\x00\x62\x00\x8f\x00\x64\x00\x65\x00\x20\x00\x21\x00\x68\x00\x69\x00\x6a\x00\x2a\x00\x2b\x00\x3e\x00\xb1\x00\x6f\x00\x9c\x00\x9d\x00\x9e\x00\x4a\x00\x51\x00\x05\x00\x06\x00\x77\x00\x62\x00\x89\x00\x64\x00\x65\x00\x8e\x00\x4e\x00\x68\x00\x69\x00\x6a\x00\x51\x00\x3b\x00\xac\x00\x2a\x00\x6f\x00\x2c\x00\x2d\x00\x2e\x00\x60\x00\xaa\x00\x9d\x00\x8c\x00\x77\x00\x56\x00\x8f\x00\x90\x00\x56\x00\x92\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xac\x00\x30\x00\x31\x00\xaa\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\x87\x00\x88\x00\x8f\x00\x90\x00\x61\x00\x92\x00\xa9\x00\xaa\x00\x8f\x00\x42\x00\xa0\x00\xa1\x00\x6f\x00\x36\x00\x71\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x9c\x00\x9d\x00\x9e\x00\x72\x00\x73\x00\xb0\x00\x54\x00\xa9\x00\xaa\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\x30\x00\x31\x00\x32\x00\x33\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x92\x00\x30\x00\x31\x00\x32\x00\x33\x00\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x4a\x00\x30\x00\x31\x00\xa0\x00\xa1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x16\x00\x30\x00\x31\x00\xac\x00\x1a\x00\xaa\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x8d\x00\x30\x00\x31\x00\x7f\x00\x80\x00\x49\x00\x11\x00\x9d\x00\x9e\x00\x90\x00\xa0\x00\xa1\x00\x81\x00\x82\x00\x83\x00\x1a\x00\x9d\x00\x9e\x00\x6b\x00\x10\x00\x11\x00\x12\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xb1\x00\x6b\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x3e\x00\x30\x00\x31\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xb1\x00\x30\x00\x31\x00\x1a\x00\xaa\x00\x05\x00\x06\x00\x1e\x00\x4e\x00\x34\x00\x16\x00\xaa\x00\x23\x00\x90\x00\x1a\x00\x9d\x00\x9e\x00\x11\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x90\x00\x30\x00\x31\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x09\x00\xa3\x00\x0b\x00\x90\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xaa\x00\x9d\x00\x9e\x00\x90\x00\x11\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x41\x00\x1f\x00\x1a\x00\x90\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xb1\x00\xa6\x00\x11\x00\x08\x00\x09\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x1a\x00\x08\x00\x09\x00\x3e\x00\xb1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xad\x00\x30\x00\x31\x00\x1d\x00\x11\x00\xb1\x00\x90\x00\x05\x00\x06\x00\x4e\x00\xac\x00\x1c\x00\x1d\x00\x1a\x00\x90\x00\x29\x00\x2a\x00\x2b\x00\x10\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x29\x00\x2a\x00\x2b\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x1a\x00\x36\x00\x4e\x00\x38\x00\x39\x00\x90\x00\x20\x00\xb1\x00\xa0\x00\xa1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xb1\x00\x30\x00\x31\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x36\x00\xb0\x00\x08\x00\x39\x00\x0a\x00\xac\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xb1\x00\x30\x00\x31\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x1d\x00\x30\x00\x31\x00\x1c\x00\x1d\x00\x08\x00\x1f\x00\x20\x00\x13\x00\x05\x00\x06\x00\x24\x00\x29\x00\x2a\x00\x2b\x00\x1a\x00\x29\x00\x2a\x00\x2b\x00\x90\x00\x10\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x1d\x00\x30\x00\x31\x00\x26\x00\x05\x00\x06\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2e\x00\x29\x00\x2a\x00\x2b\x00\x10\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xa3\x00\x30\x00\x31\x00\xa6\x00\x88\x00\xb1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x8f\x00\x30\x00\x31\x00\x11\x00\x1a\x00\x9d\x00\x9e\x00\xac\x00\x90\x00\xa1\x00\x20\x00\xaa\x00\x1a\x00\x9c\x00\x9d\x00\x9e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x90\x00\x30\x00\x31\x00\xa0\x00\xa1\x00\x04\x00\x05\x00\x06\x00\x90\x00\x11\x00\xb1\x00\x05\x00\x06\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x1a\x00\xb0\x00\xab\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x05\x00\x06\x00\xb1\x00\x90\x00\x33\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xb1\x00\x30\x00\x31\x00\x4c\x00\x4d\x00\x9b\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x0f\x00\xa2\x00\xa3\x00\x90\x00\x4e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x4f\x00\x30\x00\x31\x00\xaa\x00\x90\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x28\x00\x9d\x00\x9e\x00\xa6\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x04\x00\x05\x00\x06\x00\x90\x00\xb1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xb1\x00\x30\x00\x31\x00\x90\x00\x4a\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa4\x00\x1f\x00\xa6\x00\x21\x00\xa8\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xb1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x9b\x00\x1f\x00\x90\x00\x21\x00\xb1\x00\x05\x00\x06\x00\xa2\x00\xa3\x00\xa4\x00\xac\x00\xa6\x00\x90\x00\xa8\x00\x70\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x43\x00\x44\x00\x45\x00\x90\x00\x74\x00\xb1\x00\x38\x00\x6b\x00\x3a\x00\x3b\x00\x27\x00\x26\x00\x5b\x00\x3f\x00\x27\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x05\x00\x06\x00\xaa\x00\x1a\x00\x90\x00\xb1\x00\x05\x00\x06\x00\x2a\x00\x20\x00\x2c\x00\x2d\x00\x2e\x00\x47\x00\x48\x00\x26\x00\x37\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2a\x00\x2e\x00\x2c\x00\x2d\x00\x2e\x00\x4c\x00\x4d\x00\x2a\x00\x90\x00\x2c\x00\x2d\x00\x2e\x00\x72\x00\x73\x00\x90\x00\xb1\x00\x4c\x00\x4d\x00\x4c\x00\x4d\x00\x34\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xad\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2a\x00\x55\x00\x2c\x00\x2d\x00\x2e\x00\x4c\x00\x4d\x00\x90\x00\x2a\x00\xb1\x00\x2c\x00\x2d\x00\x2e\x00\x0e\x00\x2a\x00\xb1\x00\x2c\x00\x2d\x00\x2e\x00\x18\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xab\x00\x2a\x00\x09\x00\x2c\x00\x2d\x00\x2e\x00\x8f\x00\x2a\x00\xad\x00\x2c\x00\x2d\x00\x2e\x00\x73\x00\x90\x00\xaa\x00\xb1\x00\x72\x00\x73\x00\x90\x00\x9c\x00\x9d\x00\x9e\x00\x2d\x00\x2e\x00\x2f\x00\xac\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x93\x00\x05\x00\x06\x00\x96\x00\x74\x00\x98\x00\x05\x00\x06\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x07\x00\x08\x00\xb1\x00\xa3\x00\x72\x00\x73\x00\xa6\x00\x03\x00\x04\x00\x9d\x00\x9e\x00\x25\x00\xa0\x00\xa1\x00\xad\x00\xb1\x00\x9d\x00\x9e\x00\x15\x00\xa0\x00\xa1\x00\x2c\x00\x2d\x00\x2e\x00\x03\x00\x04\x00\x2c\x00\x2d\x00\x2e\x00\xb1\x00\x61\x00\x2c\x00\x2d\x00\x2e\x00\x05\x00\x06\x00\xb1\x00\x2d\x00\x2e\x00\x3c\x00\x3d\x00\x9d\x00\x9e\x00\x4d\x00\xa0\x00\xa1\x00\x20\x00\x46\x00\x11\x00\x9d\x00\x9e\x00\x21\x00\xa0\x00\xa1\x00\x3c\x00\x9d\x00\x9e\x00\x14\x00\xa0\x00\xa1\x00\x20\x00\xb1\x00\x23\x00\x2c\x00\x2d\x00\x2e\x00\x61\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x21\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x23\x00\x97\x00\x05\x00\x06\x00\x14\x00\x9b\x00\x11\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\x21\x00\xb1\x00\x2c\x00\x2d\x00\x2e\x00\x01\x00\x14\x00\x31\x00\x2c\x00\x2d\x00\x2e\x00\x46\x00\x47\x00\xb1\x00\xb2\x00\xb3\x00\x2d\x00\x2e\x00\x11\x00\x0f\x00\x10\x00\x2d\x00\x2e\x00\x10\x00\x42\x00\x43\x00\x44\x00\x11\x00\x46\x00\x1a\x00\x42\x00\x43\x00\x44\x00\x14\x00\x46\x00\x05\x00\x06\x00\x3c\x00\x3d\x00\x2d\x00\x2e\x00\x05\x00\x9d\x00\x9e\x00\x16\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x25\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x14\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x15\x00\xa0\x00\xa1\x00\xb1\x00\x2d\x00\x2e\x00\x05\x00\x06\x00\xb1\x00\x2d\x00\x2e\x00\x42\x00\x15\x00\xb1\x00\x14\x00\x46\x00\x47\x00\x48\x00\xb1\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x28\x00\x16\x00\x9d\x00\x9e\x00\x52\x00\xa0\x00\xa1\x00\x21\x00\x11\x00\x01\x00\x14\x00\x03\x00\x04\x00\x05\x00\x06\x00\x16\x00\x1c\x00\x1d\x00\x20\x00\x1f\x00\x62\x00\x91\x00\xb1\x00\x10\x00\x10\x00\x1a\x00\x12\x00\x91\x00\x16\x00\x29\x00\x2a\x00\x2b\x00\x18\x00\x9d\x00\x9e\x00\x14\x00\xa0\x00\xa1\x00\x4f\x00\x9d\x00\x9e\x00\x20\x00\xa0\x00\xa1\x00\x11\x00\x11\x00\x9d\x00\x9e\x00\x24\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x15\x00\x55\x00\x38\x00\xb1\x00\x3a\x00\x3b\x00\x11\x00\x3c\x00\x23\x00\x3f\x00\xb1\x00\x1e\x00\x2d\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x1c\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x35\x00\x1c\x00\x4d\x00\xb1\x00\x52\x00\x61\x00\x15\x00\x9d\x00\x9e\x00\x25\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x51\x00\xa0\x00\xa1\x00\x1d\x00\x23\x00\x1f\x00\x62\x00\x9c\x00\x9d\x00\x9e\x00\x11\x00\xa0\x00\xa1\x00\xb1\x00\x1a\x00\x29\x00\x2a\x00\x2b\x00\xb1\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\x9c\x00\x9d\x00\x9e\x00\x21\x00\xa0\x00\xa1\x00\x18\x00\x15\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x20\x00\x1f\x00\x16\x00\x16\x00\x22\x00\x15\x00\x1c\x00\x24\x00\x1a\x00\x27\x00\x11\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x1a\x00\x19\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x21\x00\x36\x00\x37\x00\x20\x00\x15\x00\x15\x00\x3b\x00\x16\x00\x14\x00\x01\x00\x02\x00\x48\x00\x1a\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x1a\x00\x11\x00\x20\x00\x10\x00\x4e\x00\x61\x00\x15\x00\x5f\x00\x52\x00\x53\x00\x55\x00\x15\x00\x61\x00\x11\x00\x1c\x00\x1a\x00\x5a\x00\x5b\x00\x4d\x00\x11\x00\x11\x00\x1c\x00\x1c\x00\x11\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x8f\x00\x21\x00\x11\x00\x92\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x1a\x00\x11\x00\x11\x00\x14\x00\x9c\x00\x9d\x00\x9e\x00\x18\x00\xa0\x00\xa1\x00\x1b\x00\x11\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x11\x00\x11\x00\x11\x00\x27\x00\x11\x00\x29\x00\x11\x00\x19\x00\x2c\x00\x52\x00\x11\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x61\x00\x36\x00\x37\x00\x35\x00\x39\x00\x35\x00\x3b\x00\x35\x00\x62\x00\x01\x00\x23\x00\x19\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x3e\x00\x23\x00\x23\x00\x52\x00\x15\x00\x54\x00\x11\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5e\x00\x5b\x00\x23\x00\x5d\x00\x28\x00\x20\x00\x60\x00\x21\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x61\x00\x14\x00\x62\x00\x15\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x15\x00\x59\x00\x10\x00\x50\x00\x0c\x00\x15\x00\x15\x00\x18\x00\x21\x00\x39\x00\x1b\x00\x10\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x1a\x00\x11\x00\x16\x00\x27\x00\x61\x00\x29\x00\x1f\x00\x10\x00\x2c\x00\x52\x00\x3e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x63\x00\x36\x00\x37\x00\x39\x00\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\xff\xff\x3b\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\x54\x00\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\x94\x00\xff\xff\xff\xff\x97\x00\xff\xff\x99\x00\x18\x00\x9b\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xa4\x00\xff\xff\xa6\x00\xff\xff\xa8\x00\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\x94\x00\xff\xff\xff\xff\x97\x00\xff\xff\x99\x00\x18\x00\x9b\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xa4\x00\xff\xff\xa6\x00\xff\xff\xa8\x00\x27\x00\xaa\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\x54\x00\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\x94\x00\xff\xff\xff\xff\x97\x00\xff\xff\x99\x00\x18\x00\x9b\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xa4\x00\xff\xff\xa6\x00\xff\xff\xa8\x00\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\x62\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\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\x21\x00\xff\xff\x23\x00\x01\x00\xff\xff\xff\xff\x27\x00\x05\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\x52\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\x01\x00\x02\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x16\x00\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\x01\x00\x02\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x16\x00\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\x62\x00\x01\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\x1d\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\x01\x00\x02\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\x01\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1d\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\x94\x00\xff\xff\xff\xff\x97\x00\xff\xff\x99\x00\x18\x00\x9b\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xa4\x00\xff\xff\xa6\x00\xff\xff\xa8\x00\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x94\x00\x4b\x00\xff\xff\x97\x00\x4e\x00\x99\x00\xff\xff\x9b\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xa4\x00\x5b\x00\xa6\x00\x5d\x00\xa8\x00\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\x1c\x00\x1d\x00\x52\x00\x1f\x00\x20\x00\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\x1c\x00\x1d\x00\x52\x00\x1f\x00\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x4a\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\x01\x00\x02\x00\xff\xff\x3b\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\xff\xff\x52\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x27\x00\x05\x00\x06\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x01\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\x52\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\xff\xff\x1c\x00\x25\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\xff\xff\x27\x00\x28\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\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x52\x00\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\x52\x00\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x10\x00\x11\x00\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x18\x00\x01\x00\x1a\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\x25\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x18\x00\xff\xff\xff\xff\x05\x00\x1c\x00\xff\xff\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\x10\x00\x27\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x52\x00\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x62\x00\x10\x00\x11\x00\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x18\x00\xff\xff\x1a\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x25\x00\xff\xff\x62\x00\x05\x00\x06\x00\xff\xff\xff\xff\x09\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\xff\xff\x1c\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x51\x00\x52\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\x62\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\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\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x51\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x51\x00\x52\x00\x05\x00\x06\x00\xff\xff\x01\x00\x09\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\x62\x00\xff\xff\xff\xff\x10\x00\x18\x00\x12\x00\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x2a\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\x52\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x51\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x01\x00\x51\x00\x52\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x18\x00\x12\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\x52\x00\xff\xff\x05\x00\x06\x00\xff\xff\x01\x00\xff\xff\x52\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x62\x00\xff\xff\xff\xff\xff\xff\x10\x00\x18\x00\x12\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x2a\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x28\x00\xff\xff\x52\x00\xff\xff\xff\xff\x63\x00\x64\x00\x65\x00\xff\xff\x52\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x62\x00\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\x62\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x10\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\x52\x00\xff\xff\x1a\x00\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\x10\x00\x92\x00\x12\x00\xff\xff\xff\xff\x01\x00\x02\x00\x62\x00\x18\x00\x05\x00\x06\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x62\x00\x52\x00\xff\xff\x05\x00\x06\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x62\x00\xff\xff\x01\x00\xff\xff\x52\x00\x18\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x52\x00\xff\xff\x05\x00\x06\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x52\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x02\x00\x62\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x62\x00\x05\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x10\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\x52\x00\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x52\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x62\x00\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\xff\xff\x97\x00\xff\xff\xff\xff\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\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\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\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\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\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\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\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\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\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\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\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\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\x6d\x00\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\x6d\x00\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xa9\x00\xaa\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\xa9\x00\xaa\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x62\x00\xff\xff\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x77\x00\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x64\x00\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x6f\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\x67\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\x75\x00\x76\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x6f\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\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# - -happyTable :: HappyAddr -happyTable = HappyA# "\x00\x00\x04\x00\x02\x00\x05\x00\x93\x00\x02\x00\x16\x01\xfe\x02\x10\x01\x0a\x00\x08\x00\x24\x00\x0a\x00\xb0\x01\x22\x00\x23\x00\x33\x00\x34\x00\x35\x00\x1a\x00\x3e\x02\x66\x01\xb7\x02\x28\x02\x29\x00\x24\x00\x66\x01\xf1\x02\xa2\x01\x25\x00\x26\x00\x27\x00\x5c\x01\x2c\x02\xad\x02\x94\x00\x28\x00\xbc\x02\x29\x00\xbe\x01\xd3\x00\x41\x02\xf8\x02\x08\x03\x24\x00\x24\x00\x21\x00\xbd\x02\xbe\x02\x95\x00\x26\x00\x27\x00\xd6\x02\xd4\xff\x35\x02\x36\x02\x28\x00\x29\x00\x29\x00\xa2\x02\x1a\x00\x3e\x02\x24\x00\x24\x00\x0d\x00\xae\x02\x42\x01\x26\x00\x27\x00\x22\x00\xb8\x02\xb9\x02\xba\x02\x28\x00\xb7\x02\x29\x00\x29\x00\x66\x01\x2a\x00\xd6\x01\x24\x00\xda\x02\xcd\x01\xa0\x02\x18\x03\xbf\x01\x96\x00\x24\x00\x00\x03\x19\x01\x72\x01\x28\x00\x2a\x00\x29\x00\x6e\x02\x66\x01\x4d\x01\x67\x01\xab\x02\x7c\x02\x29\x00\xa7\x00\x73\x01\x99\x00\x9a\x00\x9b\x00\x18\x01\x19\x01\xd0\x00\x74\x01\x75\x01\x2a\x00\x2a\x00\x9b\x02\x9c\x02\x1a\x00\xc7\x01\x38\x00\x9c\x00\x4d\x02\x74\x00\x1a\x00\x8a\x02\xfa\x02\xba\x02\x75\x00\xdd\x02\x90\x02\xbf\x02\x2a\x00\x2a\x00\x1f\x02\x42\x02\x76\x00\xce\x01\x0f\x00\x9d\x02\xb1\x01\x36\x00\x56\x02\x3f\x02\x59\x00\xc8\x01\x0c\x02\x38\x00\x1c\x01\xe3\x00\x2a\x00\xc0\x02\xcf\x01\x36\x00\x37\x00\x38\x00\x39\x00\x2a\x00\x3a\x00\x3b\x00\x68\x01\xbb\x02\x37\x02\x38\x02\xc1\x02\x68\x01\x37\x00\x38\x00\x39\x00\x49\x01\x3a\x00\x3b\x00\xbf\x02\x3c\x00\x06\x00\x2b\x00\x03\x00\x03\x00\x8b\x02\x0b\x00\x0b\x00\x09\x00\x0d\x00\x0b\x00\x40\x02\x3c\x00\xce\x01\x0b\x03\x38\x00\x1c\x01\xdf\x01\xe0\x01\xc0\x02\x0c\x03\x39\x02\x2b\x00\x77\x00\x74\x00\x78\x00\x79\x00\x20\x02\xcf\x01\x7a\x00\x4f\x00\x50\x00\xc1\x02\xac\x00\xcd\x01\xe1\x01\x51\x00\x76\x00\x1a\x01\x97\x00\xbb\x02\xa4\x00\x1b\x01\x68\x01\x7b\x00\x0e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xa2\x02\x9b\x00\x9d\x02\x38\x00\x1c\x01\x1a\x01\x97\x00\x1d\x01\xf9\x02\x1b\x01\x68\x01\x1a\x00\xc7\x01\xac\x02\x55\x00\x9e\x00\xe5\x02\x7c\x00\x57\x00\x20\x02\x58\x00\x38\x00\x1c\x01\x20\x02\xa3\x02\x1d\x01\xc9\x01\xb0\x00\xa5\x00\x0f\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x38\x00\x9c\x00\xca\x01\x9d\x00\x3b\x00\x1a\x01\xcf\x02\x5b\x00\x5c\x00\x1b\x01\x77\x00\x74\x00\x78\x00\x79\x00\x12\x03\x3b\x01\x7a\x00\x4f\x00\x50\x00\x96\x02\xe4\x00\x38\x00\x1c\x01\x51\x00\x76\x00\x1d\x01\x1a\x00\x67\x02\x15\x00\xa5\x00\x4a\x01\x7b\x00\x16\x00\x4b\x01\x17\x00\x4c\x01\xed\x01\xe1\x01\xc3\x02\x1a\x00\x67\x02\x5e\x02\x5f\x02\x60\x02\x61\x02\x47\x01\x4d\x01\x1a\x00\x4f\x02\x4e\x01\x1a\x00\x4f\x02\x55\x00\x96\x02\x06\x01\x7c\x00\x57\x00\x33\x01\x58\x00\xca\x02\x60\x02\x61\x02\x1a\x00\x8a\x02\x3b\x01\x48\x01\x34\x01\xe5\x01\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x8d\x02\x35\x01\x38\x00\x9c\x00\x99\x02\x9d\x00\x3b\x00\x5b\x00\x5c\x00\x3c\x01\x77\x00\xe8\x02\x78\x00\x79\x00\x54\x01\x55\x01\x7a\x00\x4f\x00\x50\x00\xe6\x01\xe7\x01\x03\x03\x9e\x00\x51\x00\x37\x00\x38\x00\x39\x00\x18\x00\x68\x02\xd4\x02\xd5\x02\x7b\x00\x77\x00\xcb\x01\x78\x00\x79\x00\x2e\x02\x04\x03\x7a\x00\x4f\x00\x50\x00\x69\x02\x8c\x02\xb5\x02\xcb\x02\x51\x00\x99\x00\x9a\x00\x9b\x00\x19\x00\x62\x02\xcf\x01\x55\x00\x7b\x00\x50\x02\x7c\x00\x71\x02\x51\x02\x58\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x5c\x02\x17\x03\xab\x00\x62\x02\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x21\x01\x22\x01\x56\x00\x57\x00\x3e\xff\x58\x00\x5b\x00\x5c\x00\x23\x01\xbe\x00\x1c\x02\x3b\x00\x00\x02\x65\x02\x01\x02\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x37\x00\x38\x00\x39\x00\xf0\x02\x13\x00\x8e\x02\xbf\x00\x5b\x00\x5c\x00\xa7\x00\x92\x01\xa9\x00\x9a\x00\x9b\x00\x9b\x01\x93\x01\xab\x00\x94\x01\x75\x01\xa7\x00\x92\x01\xa9\x00\x9a\x00\x9b\x00\xea\x02\x93\x01\xab\x00\x94\x01\x75\x01\x9c\x01\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x1b\x02\x0f\x03\xab\x00\x5a\x00\x3b\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xf4\x02\x06\x03\xab\x00\x6a\x02\xf5\x02\x5c\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x56\x01\x13\x03\xab\x00\x6c\x02\x6d\x02\x10\x03\x0b\x03\x38\x00\x9c\x00\xac\x00\x9d\x00\x3b\x00\xd7\x02\xd8\x02\xd9\x02\x0c\x02\x38\x00\x1c\x01\x45\x01\x49\x02\x4a\x02\x4b\x02\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x9e\x00\x45\x01\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xea\x01\xfd\x02\xab\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x9e\x00\xcc\x02\xab\x00\x38\x01\x6e\x02\x40\x00\x41\x00\x39\x01\xeb\x01\x7d\x02\x07\x02\xda\x02\x3a\x01\xac\x00\x08\x02\x38\x00\x9c\x00\x90\x02\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xac\x00\x3d\x02\xab\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xd3\x00\x09\x02\xd5\x00\xac\x00\x45\x02\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x29\x02\x38\x00\x9c\x00\xac\x00\x98\x02\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x24\x02\xd8\x00\x99\x02\xac\x00\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x4e\x02\x2d\x02\xf1\x01\xd2\x00\xd3\x00\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x32\x01\xd2\x00\xd3\x00\x51\x01\x9e\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x48\x02\x4d\x02\xab\x00\xd7\x00\x0b\x02\x9e\x00\xac\x00\x57\xfe\x57\xfe\x52\x01\x31\x02\x50\x01\xd7\x00\x0c\x02\xac\x00\xda\x00\xdb\x00\xdc\x00\x57\xfe\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xda\x00\xdb\x00\xdc\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xdd\x00\xb9\x01\x9f\x01\xba\x01\xbb\x01\xac\x00\xf6\x02\x9e\x00\x1c\x02\x3b\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x9e\x00\x56\x02\xab\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xb9\x01\xee\x02\xd2\x00\x66\x02\xd4\x00\x32\x02\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x9e\x00\x97\x01\xab\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xd7\x00\x50\x01\xab\x00\xd6\x00\xd7\x00\xd2\x00\xd8\x00\x6e\x01\x9d\x01\x40\x00\x41\x00\xaf\xfe\xda\x00\xdb\x00\xdc\x00\x9e\x01\xda\x00\xdb\x00\xdc\x00\xac\x00\xec\x02\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xd7\x00\x55\x01\xab\x00\xc2\x00\x40\x00\x41\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xc3\x00\xda\x00\xdb\x00\xdc\x00\x1f\x02\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x09\x02\x71\x01\xab\x00\xde\x01\x0e\x02\x9e\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x23\x01\x76\x01\xab\x00\x2f\x01\xdd\x00\x38\x00\xec\x01\xa1\x01\xac\x00\xed\x01\xde\x00\xa5\x01\x30\x01\x37\x00\x38\x00\x39\x00\xfb\x02\xfc\x02\x99\x00\x9a\x00\x9b\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xac\x00\xaa\x00\xab\x00\x1c\x02\x3b\x00\x19\x00\x1a\x00\x1b\x00\xac\x00\x31\x01\x9e\x00\xec\x02\xed\x02\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x32\x01\x1d\x02\xac\x01\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xa7\x00\x90\x01\x99\x00\x9a\x00\x9b\x00\xb3\x02\xb4\x02\x9e\x00\xac\x00\x91\x01\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x9e\x00\xb4\x00\xab\x00\xc2\x02\xe3\x01\x43\x01\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xb4\x01\xcb\x00\xcc\x00\xac\x00\xb8\x01\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xbc\x01\xde\x00\xab\x00\xc1\x01\xac\x00\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xd2\x01\x38\x00\x9c\x00\xde\x01\x29\x01\x3b\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x1c\x00\x1a\x00\x1b\x00\xac\x00\x9e\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xa9\x01\xeb\x00\xab\x00\xac\x00\xe8\x01\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xff\x00\xd3\xfe\xce\x00\xd3\xfe\xcf\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xa7\x00\x47\x02\x99\x00\x9a\x00\x9b\x00\x9e\x00\xa7\x00\x57\x02\x99\x00\x9a\x00\x9b\x00\x43\x01\xd4\xfe\xac\x00\xd4\xfe\x9e\x00\xc6\x02\xc7\x02\xcb\x00\xcc\x00\xff\x00\xf1\x01\xce\x00\xac\x00\xcf\x00\x26\x01\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xa7\x00\xae\x01\x99\x00\x9a\x00\x9b\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xd4\x01\xd5\x01\xd6\x01\xac\x00\xff\x01\x9e\x00\x03\x02\x45\x01\xf0\x02\x73\x00\x62\x01\xe5\x02\x5d\x01\x05\x02\x65\x01\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xa7\x00\x8e\x01\x99\x00\x9a\x00\x9b\x00\xa7\x00\x8f\x01\x99\x00\x9a\x00\x9b\x00\x72\x02\x73\x02\x6b\x01\x9a\xff\xac\x00\x9e\x00\x74\x02\x75\x02\xaa\x02\x9a\xff\x99\x00\x9a\x00\x9b\x00\xe6\x02\xe7\x02\xc2\x00\x6f\x01\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x76\x02\xc3\x00\x99\x00\x9a\x00\x9b\x00\x88\x02\xe3\x01\xa8\x01\xac\x00\x99\x00\x9a\x00\x9b\x00\x12\x02\x13\x00\xac\x00\x9e\x00\x22\x02\xe3\x01\x58\x02\xe3\x01\x78\x01\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x77\x01\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xaa\x01\x7b\x01\x99\x00\x9a\x00\x9b\x00\xe2\x01\xe3\x01\xac\x00\xab\x01\x9e\x00\x99\x00\x9a\x00\x9b\x00\xae\x00\xaf\x01\x9e\x00\x99\x00\x9a\x00\x9b\x00\xe0\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xea\x00\x8d\x01\x13\x01\x99\x00\x9a\x00\x9b\x00\xe8\x02\x98\x00\x11\x01\x99\x00\x9a\x00\x9b\x00\x73\x00\xac\x00\x1e\x00\x9e\x00\x27\x01\x13\x00\xac\x00\x37\x00\x38\x00\x39\x00\x7d\x01\x9b\x00\x7e\x01\x1f\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x4a\x01\x8f\x00\x90\x00\x4b\x01\x2f\x00\x17\x02\x91\x00\x92\x00\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\x30\x00\x31\x00\x9e\x00\x4d\x01\x12\x00\x13\x00\x4e\x01\x5f\x00\x60\x00\x38\x00\x9c\x00\x17\x03\x9d\x00\x3b\x00\x0f\x00\x9e\x00\x38\x00\x9c\x00\x22\x02\x9d\x00\x3b\x00\xe3\x02\x9a\x00\x9b\x00\x57\xfe\x57\xfe\xdf\x02\x9a\x00\x9b\x00\x9e\x00\x08\x03\x98\x01\x9a\x00\x9b\x00\x40\x00\x41\x00\x9e\x00\x15\x03\x9b\x00\x93\x02\x94\x02\x38\x00\x9c\x00\xea\x01\x9d\x00\x3b\x00\x54\x01\xe4\x02\x0a\x03\x38\x00\x9c\x00\x0e\x03\x9d\x00\x3b\x00\x15\x03\x38\x00\x9c\x00\x2d\x00\x9d\x00\x3b\x00\xf3\x02\x9e\x00\xf8\x02\xa7\x01\x9a\x00\x9b\x00\x5f\x01\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\xb0\x02\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\x57\xfe\x7f\x01\x11\x00\x12\x00\x2d\x00\xca\x00\x00\x03\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\xcb\x00\xcc\x00\x06\x03\x9e\x00\x7e\x02\x9a\x00\x9b\x00\x3e\x00\x2d\x00\x7f\x02\xe0\x02\x9a\x00\x9b\x00\x64\x01\x65\x01\x9e\x00\x80\x01\x81\x01\x7d\x01\x9b\x00\xce\x02\xd1\x01\xd2\x01\xde\x02\x9b\x00\xcf\x02\x80\x02\x81\x02\x82\x02\xd2\x02\x83\x02\xd1\x02\xe1\x02\x81\x02\x82\x02\x2d\x00\x83\x02\x11\x00\x12\x00\x0d\x01\x0e\x01\xe2\x02\x9b\x00\x40\x00\x38\x00\x9c\x00\x9b\x02\x9d\x00\x3b\x00\x38\x00\x9c\x00\xdc\x02\x9d\x00\x3b\x00\x38\x00\x9c\x00\x2d\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x94\xfe\x9d\x00\x3b\x00\x9e\x00\x9e\x02\x9b\x00\x11\x00\x12\x00\x9e\x00\x7d\x01\x9b\x00\x44\x00\xa0\x02\x9e\x00\x2d\x00\x48\x00\x49\x00\x4a\x00\x9e\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xa6\x02\xb7\x02\x38\x00\x9c\x00\x4b\x00\x9d\x00\x3b\x00\xb0\x02\x5a\x02\x3e\x00\xc9\x02\x5f\x00\x60\x00\x40\x00\x41\x00\x5e\x02\xd6\x00\xd7\x00\x64\x02\xd8\x00\x4d\x00\x84\x02\x9e\x00\x65\x02\xa0\x00\x74\xff\xa1\x00\x84\x02\x6c\x02\xda\x00\xdb\x00\xdc\x00\xa2\x00\x38\x00\x9c\x00\x2d\x00\x9d\x00\x85\x02\x71\x02\x38\x00\x9c\x00\x78\x02\x9d\x00\x85\x02\x79\x02\x8a\x02\x38\x00\x9c\x00\x7c\x02\x9d\x00\x3b\x00\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\x22\x02\xcd\x01\x03\x02\x9e\x00\x04\x02\x73\x00\x0e\x02\x95\x02\x35\x01\x05\x02\x9e\x00\x15\x02\x16\x02\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x19\x02\xd2\x00\xd3\x00\xd4\x00\xd5\x00\x17\x02\x1a\x02\xea\x01\x9e\x00\x4b\x00\x1b\x02\x22\x02\x38\x00\x9c\x00\x24\x02\x9d\x00\x3b\x00\x38\x00\x9c\x00\x26\x02\x9d\x00\x3b\x00\xd7\x00\x27\x02\xd8\x00\x4d\x00\x28\x01\x38\x00\x39\x00\x28\x02\x29\x01\x3b\x00\x9e\x00\x2b\x02\xda\x00\xdb\x00\xdc\x00\x9e\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x04\x01\xd3\x00\xd4\x00\xd5\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x05\x01\x59\x01\x38\x00\x39\x00\x2c\x02\x29\x01\x3b\x00\x67\x00\x6a\x01\x06\x01\x68\x00\x07\x01\x08\x01\x30\x02\xd8\x00\x34\x02\x35\x02\xbb\x00\x44\x02\x53\x02\x55\x02\x45\x02\x69\x00\x9a\x01\x09\x01\x0a\x01\x0b\x01\x6a\x00\x75\xff\x9f\x01\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\xa1\x01\x71\x00\x72\x00\x54\x01\x6a\x01\xae\x01\x73\x00\xa5\x01\xa7\x01\x3e\x00\x3f\x00\xb6\x01\xb7\x01\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x75\xff\xb8\x01\x54\x01\x42\x00\x87\x00\xbe\x01\xc1\x01\xc7\x01\x4b\x00\xbc\x00\xcd\x01\x6a\x01\xe8\x01\xf0\x01\xde\x01\xef\x01\xbd\x00\x8d\x00\xea\x01\x2c\x01\xfd\x01\xfe\x01\xff\x01\x09\x02\x4d\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\xe7\x00\x06\x02\x18\x01\xe8\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x36\x01\x61\xfe\x63\xfe\x2d\x00\x37\x00\x38\x00\x39\x00\x57\xfe\x5a\x00\x3b\x00\x57\xfe\x62\xfe\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x65\xfe\x68\xfe\x2b\x01\x57\xfe\x2c\x01\x57\xfe\x2e\x01\x37\x01\x57\xfe\x4b\x00\x3e\x01\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x5f\x01\x57\xfe\x57\xfe\x3f\x01\x57\xfe\x41\x01\x57\xfe\x42\x01\x4d\x00\x3e\x00\x3d\x01\x45\x01\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x49\x01\x5b\x01\x57\xfe\x57\xfe\x6a\x01\x57\xfe\x62\x01\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x6f\x01\x57\xfe\x71\x01\x57\xfe\x7b\x01\x7a\x01\x57\xfe\x97\x01\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x7d\x01\x2d\x00\xb0\x00\xa7\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\xa7\x00\xb2\x00\xb3\x00\xb4\x00\xe2\x00\x10\x01\x0d\x00\x57\xfe\x0f\x01\x0c\x01\x57\xfe\x13\x01\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x15\x01\x16\x01\x2e\x00\x57\xfe\x4e\x00\x57\xfe\x2f\x00\x33\x00\x57\xfe\x4b\x00\x1e\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\xff\xff\x57\xfe\x57\xfe\x0e\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x00\x00\x08\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\xc7\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc9\x00\x57\xfe\xca\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\xcc\x00\xcd\x00\x00\x00\xce\x00\x00\x00\xcf\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\xc4\x00\xc5\x00\xc6\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\xc7\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc9\x00\x67\x00\xca\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\xcc\x00\xcd\x00\x00\x00\xce\x00\x00\x00\xcf\x00\x69\x00\xd0\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x80\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x88\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x00\x00\x8d\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\xc7\x00\x00\x00\x00\x00\xc8\x00\x00\x00\x6c\x01\x67\x00\xca\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\xcc\x00\xcd\x00\x00\x00\xce\x00\x00\x00\xcf\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x80\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x00\x00\x8d\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x4d\x00\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\x00\x00\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xef\xfe\x00\x00\x00\x00\xef\xfe\x00\x00\x00\x00\xef\xfe\xef\xfe\xef\xfe\x00\x00\xef\xfe\x00\x00\xef\xfe\x00\x00\xef\xfe\x3e\x00\x00\x00\x00\x00\xef\xfe\x40\x00\xef\xfe\xef\xfe\xef\xfe\xef\xfe\x00\x00\x00\x00\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\x00\x00\xef\xfe\xef\xfe\x00\x00\xef\xfe\x00\x00\xef\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\xef\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\xef\xfe\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\xef\xfe\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x42\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\xea\x02\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x42\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x25\x01\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x4b\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x4d\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\xd3\x02\x00\x00\xb3\x01\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x00\x00\xa9\x02\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x02\x00\x00\x4d\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x42\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x8b\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x57\xfe\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x8b\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x58\x01\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\xb3\x01\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x01\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x8b\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x57\xfe\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x8b\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x57\xfe\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x8b\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\xf7\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\xd2\x01\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x4b\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\xc7\x00\x00\x00\x00\x00\xc8\x00\x00\x00\x3f\x01\x67\x00\xca\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\xcc\x00\xcd\x00\x00\x00\xce\x00\x00\x00\xcf\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\xc7\x00\xc5\x02\x00\x00\xc8\x00\x87\x00\x6c\x01\x00\x00\xca\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\xcc\x00\xcd\x00\x8d\x00\xce\x00\x8e\x00\xcf\x00\x00\x00\xc6\x02\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\xd6\x00\xd7\x00\x4b\x00\xd8\x00\x6e\x01\x00\x00\x89\x00\x8a\x00\x8b\x00\x00\x00\x00\x00\x8d\x00\x00\x00\xda\x00\xdb\x00\xdc\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x57\xfe\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\xd2\x00\xd3\x00\xd4\x00\xd5\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\xd6\x00\xd7\x00\x57\xfe\xd8\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\xda\x00\xdb\x00\xdc\x00\x00\x00\x00\x00\x57\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x5e\x00\x3f\x00\x5f\x00\x60\x00\x61\x00\x41\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\xcb\xfe\xcb\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x18\x00\x00\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x4d\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x3e\x00\x3f\x00\x00\x00\x73\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3d\x02\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x4b\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x4d\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x69\x00\x40\x00\x41\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x57\xfe\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x4d\x00\x68\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x4b\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x83\x01\xd3\x00\x4b\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x4d\x00\x00\x00\x84\x01\x47\x02\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x01\x00\x00\x86\x01\x78\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\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x4b\x00\x00\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\xa0\x00\x47\x01\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\xa2\x00\x3e\x00\x06\x01\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x83\x01\xd3\x00\x00\x00\xd5\x00\x00\x00\x48\x01\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\xa2\x00\x00\x00\x00\x00\x40\x00\x84\x01\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x01\x58\x01\x96\x01\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x4b\x00\x00\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x4d\x00\xa0\x00\x47\x01\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xa2\x00\x00\x00\x06\x01\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x48\x01\x00\x00\x4d\x00\x40\x00\x41\x00\x00\x00\x00\x00\x50\xff\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x4d\x00\x00\x00\x50\xff\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\xa7\x02\x78\xff\x00\x00\xa8\x02\x00\x00\x00\x00\x00\x00\xae\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x12\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\xae\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x4d\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\xae\x00\x4b\x00\x40\x00\x41\x00\x00\x00\x3e\x00\x50\xff\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x4d\x00\x00\x00\x00\x00\xa0\x00\xa2\x00\xa1\x00\x00\x00\x00\x00\x50\xff\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\xa8\x02\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x45\x01\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\xae\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x4d\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x3e\x00\xae\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x87\x02\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\xa2\x00\xa1\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x00\x00\x3e\x00\x00\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x87\x02\xa2\x00\xa1\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\xa5\x02\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x88\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x77\xff\x00\x00\x4b\x00\x00\x00\x00\x00\xc2\x01\x5b\x01\x79\x00\x00\x00\x4b\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x4d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x40\x00\x41\x00\x4d\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x42\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x40\x00\x41\x00\x4b\x00\x00\x00\x43\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\xa0\x00\x58\x00\xa1\x00\x00\x00\x00\x00\x3e\x00\x3f\x00\x4d\x00\xa2\x00\x40\x00\x41\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x4d\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x4d\x00\x00\x00\x3e\x00\x00\x00\x4b\x00\xa2\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x1f\x01\x02\x03\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x03\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x01\x20\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x21\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xe6\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xe7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x3f\x00\x4d\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x4d\x00\x40\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x58\x01\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4b\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4b\x00\x00\x00\xf7\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\xf8\x00\xf9\x00\x4d\x00\xfa\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\xfb\x00\x00\x00\xfc\x00\x00\x00\x00\x00\xfd\x00\xfe\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xcb\x00\xcc\x00\xff\x00\x00\x01\xce\x00\x01\x01\x02\x01\x5b\x00\x5c\x00\xd7\x01\xb6\x00\xb7\x00\x87\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x0e\x03\xd9\x01\xda\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xd7\x01\xb6\x00\xb7\x00\x87\x01\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\xd8\x01\xd9\x01\xda\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xd7\x01\xb6\x00\xb7\x00\x87\x01\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\xf2\x01\xd9\x01\xda\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xd7\x01\xb6\x00\xb7\x00\x87\x01\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\xf4\x01\xd9\x01\xda\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x86\x01\xb6\x00\xb7\x00\x87\x01\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x01\x00\x00\xc9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x86\x01\xb6\x00\xb7\x00\x87\x01\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x01\x00\x00\x5a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xd7\x01\xb6\x00\xb7\x00\x87\x01\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x86\x01\xb6\x00\xb7\x00\x87\x01\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x01\x00\x00\x53\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x86\x01\xb6\x00\xb7\x00\x87\x01\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x01\x00\x00\xa3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x86\x01\xb6\x00\xb7\x00\x87\x01\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x01\x00\x00\x89\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x86\x01\xb6\x00\xb7\x00\x87\x01\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x01\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf3\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\xf4\x00\xf5\x00\x00\x00\x10\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x11\x02\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf8\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\xf9\x01\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\xf0\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\xf1\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x19\x03\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\xf6\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xdc\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\xa9\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xb0\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x5b\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x6f\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x79\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x91\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x0f\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x30\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x3a\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf3\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\xf5\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf6\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\xf7\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xfa\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\xfb\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x58\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x6a\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\xbf\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xe2\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\xee\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xef\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x01\xb7\x00\xed\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\xec\x00\xb7\x00\xed\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\xb1\x02\x00\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x7b\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x02\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x5b\x01\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xc3\x01\xc4\x01\xc5\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x02\xc5\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x51\x00\x00\x00\x00\x00\x52\x00\x13\x00\x00\x00\x53\x00\x13\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x51\x00\x00\x00\x00\x00\x52\x00\x13\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x5f\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x60\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\xf2\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# - -happyReduceArr = array (1, 436) [ - (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) - ] - -happy_n_terms = 100 :: Int -happy_n_nonterms = 180 :: Int - -happyReduce_1 = happyMonadReduce 1# 0# happyReduction_1 -happyReduction_1 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut5 happy_x_1 of { happy_var_1 -> - ( mkPageModule happy_var_1)} - ) (\r -> happyReturn (happyIn4 r)) - -happyReduce_2 = happyMonadReduce 5# 0# happyReduction_2 -happyReduction_2 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut6 happy_x_2 of { happy_var_2 -> - case happyOut174 happy_x_4 of { happy_var_4 -> - case happyOut5 happy_x_5 of { happy_var_5 -> - ( mkPage happy_var_2 happy_var_4 happy_var_5)}}} - ) (\r -> happyReturn (happyIn4 r)) - -happyReduce_3 = happySpecReduce_1 0# happyReduction_3 -happyReduction_3 happy_x_1 - = case happyOut6 happy_x_1 of { happy_var_1 -> - happyIn4 - (happy_var_1 - )} - -happyReduce_4 = happyMonadReduce 10# 1# happyReduction_4 -happyReduction_4 (happy_x_10 `HappyStk` - happy_x_9 `HappyStk` - happy_x_8 `HappyStk` - happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut118 happy_x_3 of { happy_var_3 -> - case happyOut120 happy_x_4 of { happy_var_4 -> - case happyOut122 happy_x_5 of { happy_var_5 -> - case happyOut116 happy_x_7 of { happy_var_7 -> - case happyOut118 happy_x_9 of { happy_var_9 -> - ( do { n <- checkEqNames happy_var_3 happy_var_9; - let { cn = reverse happy_var_7; - as = reverse happy_var_4; }; - return $ HsXTag happy_var_1 n as happy_var_5 cn })}}}}}} - ) (\r -> happyReturn (happyIn5 r)) - -happyReduce_5 = happyReduce 6# 1# happyReduction_5 -happyReduction_5 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut118 happy_x_3 of { happy_var_3 -> - case happyOut120 happy_x_4 of { happy_var_4 -> - case happyOut122 happy_x_5 of { happy_var_5 -> - happyIn5 - (HsXETag happy_var_1 happy_var_3 (reverse happy_var_4) happy_var_5 - ) `HappyStk` happyRest}}}} - -happyReduce_6 = happyReduce 6# 2# happyReduction_6 -happyReduction_6 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut177 happy_x_3 of { happy_var_3 -> - case happyOut11 happy_x_4 of { happy_var_4 -> - case happyOut7 happy_x_6 of { happy_var_6 -> - happyIn6 - (HsModule happy_var_1 happy_var_3 happy_var_4 (fst happy_var_6) (snd happy_var_6) - ) `HappyStk` happyRest}}}} - -happyReduce_7 = happySpecReduce_2 2# happyReduction_7 -happyReduction_7 happy_x_2 - happy_x_1 - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_2 of { happy_var_2 -> - happyIn6 - (HsModule happy_var_1 main_mod (Just [HsEVar (UnQual main_name)]) - (fst happy_var_2) (snd happy_var_2) - )}} - -happyReduce_8 = happySpecReduce_3 3# happyReduction_8 -happyReduction_8 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut8 happy_x_2 of { happy_var_2 -> - happyIn7 - (happy_var_2 - )} - -happyReduce_9 = happySpecReduce_3 3# happyReduction_9 -happyReduction_9 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut8 happy_x_2 of { happy_var_2 -> - happyIn7 - (happy_var_2 - )} - -happyReduce_10 = happyReduce 4# 4# happyReduction_10 -happyReduction_10 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut16 happy_x_2 of { happy_var_2 -> - case happyOut31 happy_x_4 of { happy_var_4 -> - happyIn8 - ((reverse happy_var_2, happy_var_4) - ) `HappyStk` happyRest}} - -happyReduce_11 = happySpecReduce_2 4# happyReduction_11 -happyReduction_11 happy_x_2 - happy_x_1 - = case happyOut31 happy_x_2 of { happy_var_2 -> - happyIn8 - (([], happy_var_2) - )} - -happyReduce_12 = happySpecReduce_3 4# happyReduction_12 -happyReduction_12 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut16 happy_x_2 of { happy_var_2 -> - happyIn8 - ((reverse happy_var_2, []) - )} - -happyReduce_13 = happySpecReduce_1 4# happyReduction_13 -happyReduction_13 happy_x_1 - = happyIn8 - (([], []) - ) - -happyReduce_14 = happySpecReduce_2 5# happyReduction_14 -happyReduction_14 happy_x_2 - happy_x_1 - = happyIn9 - (() - ) - -happyReduce_15 = happySpecReduce_1 6# happyReduction_15 -happyReduction_15 happy_x_1 - = happyIn10 - (() - ) - -happyReduce_16 = happySpecReduce_0 6# happyReduction_16 -happyReduction_16 = happyIn10 - (() - ) - -happyReduce_17 = happySpecReduce_1 7# happyReduction_17 -happyReduction_17 happy_x_1 - = case happyOut12 happy_x_1 of { happy_var_1 -> - happyIn11 - (Just happy_var_1 - )} - -happyReduce_18 = happySpecReduce_0 7# happyReduction_18 -happyReduction_18 = happyIn11 - (Nothing - ) - -happyReduce_19 = happyReduce 4# 8# happyReduction_19 -happyReduction_19 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut14 happy_x_2 of { happy_var_2 -> - happyIn12 - (reverse happy_var_2 - ) `HappyStk` happyRest} - -happyReduce_20 = happySpecReduce_3 8# happyReduction_20 -happyReduction_20 happy_x_3 - happy_x_2 - happy_x_1 - = happyIn12 - ([] - ) - -happyReduce_21 = happySpecReduce_1 9# happyReduction_21 -happyReduction_21 happy_x_1 - = happyIn13 - (() - ) - -happyReduce_22 = happySpecReduce_0 9# happyReduction_22 -happyReduction_22 = happyIn13 - (() - ) - -happyReduce_23 = happySpecReduce_3 10# happyReduction_23 -happyReduction_23 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut14 happy_x_1 of { happy_var_1 -> - case happyOut15 happy_x_3 of { happy_var_3 -> - happyIn14 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_24 = happySpecReduce_1 10# happyReduction_24 -happyReduction_24 happy_x_1 - = case happyOut15 happy_x_1 of { happy_var_1 -> - happyIn14 - ([happy_var_1] - )} - -happyReduce_25 = happySpecReduce_1 11# happyReduction_25 -happyReduction_25 happy_x_1 - = case happyOut147 happy_x_1 of { happy_var_1 -> - happyIn15 - (HsEVar happy_var_1 - )} - -happyReduce_26 = happySpecReduce_1 11# happyReduction_26 -happyReduction_26 happy_x_1 - = case happyOut179 happy_x_1 of { happy_var_1 -> - happyIn15 - (HsEAbs happy_var_1 - )} - -happyReduce_27 = happyReduce 4# 11# happyReduction_27 -happyReduction_27 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut179 happy_x_1 of { happy_var_1 -> - happyIn15 - (HsEThingAll happy_var_1 - ) `HappyStk` happyRest} - -happyReduce_28 = happySpecReduce_3 11# happyReduction_28 -happyReduction_28 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut179 happy_x_1 of { happy_var_1 -> - happyIn15 - (HsEThingWith happy_var_1 [] - )} - -happyReduce_29 = happyReduce 4# 11# happyReduction_29 -happyReduction_29 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut179 happy_x_1 of { happy_var_1 -> - case happyOut25 happy_x_3 of { happy_var_3 -> - happyIn15 - (HsEThingWith happy_var_1 (reverse happy_var_3) - ) `HappyStk` happyRest}} - -happyReduce_30 = happySpecReduce_2 11# happyReduction_30 -happyReduction_30 happy_x_2 - happy_x_1 - = case happyOut177 happy_x_2 of { happy_var_2 -> - happyIn15 - (HsEModuleContents happy_var_2 - )} - -happyReduce_31 = happySpecReduce_3 12# happyReduction_31 -happyReduction_31 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut16 happy_x_1 of { happy_var_1 -> - case happyOut17 happy_x_3 of { happy_var_3 -> - happyIn16 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_32 = happySpecReduce_1 12# happyReduction_32 -happyReduction_32 happy_x_1 - = case happyOut17 happy_x_1 of { happy_var_1 -> - happyIn16 - ([happy_var_1] - )} - -happyReduce_33 = happyReduce 6# 13# happyReduction_33 -happyReduction_33 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut18 happy_x_3 of { happy_var_3 -> - case happyOut177 happy_x_4 of { happy_var_4 -> - case happyOut19 happy_x_5 of { happy_var_5 -> - case happyOut20 happy_x_6 of { happy_var_6 -> - happyIn17 - (HsImportDecl happy_var_1 happy_var_4 happy_var_3 happy_var_5 happy_var_6 - ) `HappyStk` happyRest}}}}} - -happyReduce_34 = happySpecReduce_1 14# happyReduction_34 -happyReduction_34 happy_x_1 - = happyIn18 - (True - ) - -happyReduce_35 = happySpecReduce_0 14# happyReduction_35 -happyReduction_35 = happyIn18 - (False - ) - -happyReduce_36 = happySpecReduce_2 15# happyReduction_36 -happyReduction_36 happy_x_2 - happy_x_1 - = case happyOut177 happy_x_2 of { happy_var_2 -> - happyIn19 - (Just happy_var_2 - )} - -happyReduce_37 = happySpecReduce_0 15# happyReduction_37 -happyReduction_37 = happyIn19 - (Nothing - ) - -happyReduce_38 = happySpecReduce_1 16# happyReduction_38 -happyReduction_38 happy_x_1 - = case happyOut21 happy_x_1 of { happy_var_1 -> - happyIn20 - (Just happy_var_1 - )} - -happyReduce_39 = happySpecReduce_0 16# happyReduction_39 -happyReduction_39 = happyIn20 - (Nothing - ) - -happyReduce_40 = happyReduce 5# 17# happyReduction_40 -happyReduction_40 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut22 happy_x_1 of { happy_var_1 -> - case happyOut23 happy_x_3 of { happy_var_3 -> - happyIn21 - ((happy_var_1, reverse happy_var_3) - ) `HappyStk` happyRest}} - -happyReduce_41 = happyReduce 4# 17# happyReduction_41 -happyReduction_41 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut22 happy_x_1 of { happy_var_1 -> - happyIn21 - ((happy_var_1, []) - ) `HappyStk` happyRest} - -happyReduce_42 = happySpecReduce_1 18# happyReduction_42 -happyReduction_42 happy_x_1 - = happyIn22 - (True - ) - -happyReduce_43 = happySpecReduce_0 18# happyReduction_43 -happyReduction_43 = happyIn22 - (False - ) - -happyReduce_44 = happySpecReduce_3 19# happyReduction_44 -happyReduction_44 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut23 happy_x_1 of { happy_var_1 -> - case happyOut24 happy_x_3 of { happy_var_3 -> - happyIn23 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_45 = happySpecReduce_1 19# happyReduction_45 -happyReduction_45 happy_x_1 - = case happyOut24 happy_x_1 of { happy_var_1 -> - happyIn23 - ([happy_var_1] - )} - -happyReduce_46 = happySpecReduce_1 20# happyReduction_46 -happyReduction_46 happy_x_1 - = case happyOut145 happy_x_1 of { happy_var_1 -> - happyIn24 - (HsIVar happy_var_1 - )} - -happyReduce_47 = happySpecReduce_1 20# happyReduction_47 -happyReduction_47 happy_x_1 - = case happyOut178 happy_x_1 of { happy_var_1 -> - happyIn24 - (HsIAbs happy_var_1 - )} - -happyReduce_48 = happyReduce 4# 20# happyReduction_48 -happyReduction_48 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut178 happy_x_1 of { happy_var_1 -> - happyIn24 - (HsIThingAll happy_var_1 - ) `HappyStk` happyRest} - -happyReduce_49 = happySpecReduce_3 20# happyReduction_49 -happyReduction_49 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut178 happy_x_1 of { happy_var_1 -> - happyIn24 - (HsIThingWith happy_var_1 [] - )} - -happyReduce_50 = happyReduce 4# 20# happyReduction_50 -happyReduction_50 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut178 happy_x_1 of { happy_var_1 -> - case happyOut25 happy_x_3 of { happy_var_3 -> - happyIn24 - (HsIThingWith happy_var_1 (reverse happy_var_3) - ) `HappyStk` happyRest}} - -happyReduce_51 = happySpecReduce_3 21# happyReduction_51 -happyReduction_51 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut25 happy_x_1 of { happy_var_1 -> - case happyOut26 happy_x_3 of { happy_var_3 -> - happyIn25 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_52 = happySpecReduce_1 21# happyReduction_52 -happyReduction_52 happy_x_1 - = case happyOut26 happy_x_1 of { happy_var_1 -> - happyIn25 - ([happy_var_1] - )} - -happyReduce_53 = happySpecReduce_1 22# happyReduction_53 -happyReduction_53 happy_x_1 - = case happyOut145 happy_x_1 of { happy_var_1 -> - happyIn26 - (HsVarName happy_var_1 - )} - -happyReduce_54 = happySpecReduce_1 22# happyReduction_54 -happyReduction_54 happy_x_1 - = case happyOut149 happy_x_1 of { happy_var_1 -> - happyIn26 - (HsConName happy_var_1 - )} - -happyReduce_55 = happyReduce 4# 23# happyReduction_55 -happyReduction_55 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_2 of { happy_var_2 -> - case happyOut28 happy_x_3 of { happy_var_3 -> - case happyOut30 happy_x_4 of { happy_var_4 -> - happyIn27 - (HsInfixDecl happy_var_1 happy_var_2 happy_var_3 (reverse happy_var_4) - ) `HappyStk` happyRest}}}} - -happyReduce_56 = happySpecReduce_0 24# happyReduction_56 -happyReduction_56 = happyIn28 - (9 - ) - -happyReduce_57 = happyMonadReduce 1# 24# happyReduction_57 -happyReduction_57 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> - ( checkPrec happy_var_1)} - ) (\r -> happyReturn (happyIn28 r)) - -happyReduce_58 = happySpecReduce_1 25# happyReduction_58 -happyReduction_58 happy_x_1 - = happyIn29 - (HsAssocNone - ) - -happyReduce_59 = happySpecReduce_1 25# happyReduction_59 -happyReduction_59 happy_x_1 - = happyIn29 - (HsAssocLeft - ) - -happyReduce_60 = happySpecReduce_1 25# happyReduction_60 -happyReduction_60 happy_x_1 - = happyIn29 - (HsAssocRight - ) - -happyReduce_61 = happySpecReduce_3 26# happyReduction_61 -happyReduction_61 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut30 happy_x_1 of { happy_var_1 -> - case happyOut156 happy_x_3 of { happy_var_3 -> - happyIn30 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_62 = happySpecReduce_1 26# happyReduction_62 -happyReduction_62 happy_x_1 - = case happyOut156 happy_x_1 of { happy_var_1 -> - happyIn30 - ([happy_var_1] - )} - -happyReduce_63 = happyMonadReduce 2# 27# happyReduction_63 -happyReduction_63 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut32 happy_x_1 of { happy_var_1 -> - ( checkRevDecls happy_var_1)} - ) (\r -> happyReturn (happyIn31 r)) - -happyReduce_64 = happySpecReduce_3 28# happyReduction_64 -happyReduction_64 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut32 happy_x_1 of { happy_var_1 -> - case happyOut33 happy_x_3 of { happy_var_3 -> - happyIn32 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_65 = happySpecReduce_1 28# happyReduction_65 -happyReduction_65 happy_x_1 - = case happyOut33 happy_x_1 of { happy_var_1 -> - happyIn32 - ([happy_var_1] - )} - -happyReduce_66 = happyMonadReduce 5# 29# happyReduction_66 -happyReduction_66 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut46 happy_x_3 of { happy_var_3 -> - case happyOut52 happy_x_5 of { happy_var_5 -> - ( do { (c,ts) <- checkSimpleType happy_var_3; - return (HsTypeDecl happy_var_1 c ts happy_var_5) })}}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_67 = happyMonadReduce 5# 29# happyReduction_67 -happyReduction_67 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut47 happy_x_4 of { happy_var_4 -> - case happyOut82 happy_x_5 of { happy_var_5 -> - ( do { (c,ts) <- checkSimpleType happy_var_4; - return (HsTypeFamDecl happy_var_1 c ts happy_var_5) })}}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_68 = happyMonadReduce 6# 29# happyReduction_68 -happyReduction_68 (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 happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut46 happy_x_4 of { happy_var_4 -> - case happyOut52 happy_x_6 of { happy_var_6 -> - ( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns - return (HsTypeInsDecl happy_var_1 happy_var_4 happy_var_6) })}}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_69 = happyMonadReduce 5# 29# happyReduction_69 -happyReduction_69 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut34 happy_x_2 of { happy_var_2 -> - case happyOut52 happy_x_3 of { happy_var_3 -> - case happyOut66 happy_x_4 of { happy_var_4 -> - case happyOut78 happy_x_5 of { happy_var_5 -> - ( do { (cs,c,t) <- checkDataHeader happy_var_3; - checkDataOrNew happy_var_2 happy_var_4; - return (HsDataDecl happy_var_1 happy_var_2 cs c t (reverse happy_var_4) happy_var_5) })}}}}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_70 = happyMonadReduce 6# 29# happyReduction_70 -happyReduction_70 (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 happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut34 happy_x_2 of { happy_var_2 -> - case happyOut52 happy_x_3 of { happy_var_3 -> - case happyOut82 happy_x_4 of { happy_var_4 -> - case happyOut62 happy_x_6 of { happy_var_6 -> - ( do { (cs,c,t) <- checkDataHeader happy_var_3; - checkDataOrNew happy_var_2 happy_var_6; - return (HsGDataDecl happy_var_1 happy_var_2 cs c t happy_var_4 (reverse happy_var_6)) })}}}}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_71 = happyMonadReduce 5# 29# happyReduction_71 -happyReduction_71 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut52 happy_x_4 of { happy_var_4 -> - case happyOut82 happy_x_5 of { happy_var_5 -> - ( do { (cs,c,t) <- checkDataHeader happy_var_4; - return (HsDataFamDecl happy_var_1 cs c t happy_var_5) })}}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_72 = happyMonadReduce 6# 29# happyReduction_72 -happyReduction_72 (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 happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut34 happy_x_2 of { happy_var_2 -> - case happyOut52 happy_x_4 of { happy_var_4 -> - case happyOut66 happy_x_5 of { happy_var_5 -> - case happyOut78 happy_x_6 of { happy_var_6 -> - ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; - checkDataOrNew happy_var_2 happy_var_5; - return (HsDataInsDecl happy_var_1 happy_var_2 happy_var_4 (reverse happy_var_5) happy_var_6) })}}}}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_73 = happyMonadReduce 7# 29# happyReduction_73 -happyReduction_73 (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 happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut34 happy_x_2 of { happy_var_2 -> - case happyOut52 happy_x_4 of { happy_var_4 -> - case happyOut82 happy_x_5 of { happy_var_5 -> - case happyOut62 happy_x_7 of { happy_var_7 -> - ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; - checkDataOrNew happy_var_2 happy_var_7; - return (HsGDataInsDecl happy_var_1 happy_var_2 happy_var_4 happy_var_5 (reverse happy_var_7)) })}}}}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_74 = happyMonadReduce 5# 29# happyReduction_74 -happyReduction_74 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut52 happy_x_3 of { happy_var_3 -> - case happyOut59 happy_x_4 of { happy_var_4 -> - case happyOut83 happy_x_5 of { happy_var_5 -> - ( do { (cs,c,vs) <- checkClassHeader happy_var_3; - return (HsClassDecl happy_var_1 cs c vs happy_var_4 happy_var_5) })}}}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_75 = happyMonadReduce 4# 29# happyReduction_75 -happyReduction_75 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut52 happy_x_3 of { happy_var_3 -> - case happyOut89 happy_x_4 of { happy_var_4 -> - ( do { (cs,c,ts) <- checkInstHeader happy_var_3; - return (HsInstDecl happy_var_1 cs c ts happy_var_4) })}}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_76 = happyMonadReduce 4# 29# happyReduction_76 -happyReduction_76 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut52 happy_x_4 of { happy_var_4 -> - ( do { (cs, c, ts) <- checkInstHeader happy_var_4; - return (HsDerivDecl happy_var_1 cs c ts) })}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_77 = happyReduce 5# 29# happyReduction_77 -happyReduction_77 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut35 happy_x_4 of { happy_var_4 -> - happyIn33 - (HsDefaultDecl happy_var_1 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_78 = happyMonadReduce 4# 29# happyReduction_78 -happyReduction_78 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - ( do { e <- checkExpr happy_var_3; - return $ HsSpliceDecl happy_var_1 $ HsParenSplice e })}} - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_79 = happyReduce 6# 29# happyReduction_79 -happyReduction_79 (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 happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut43 happy_x_4 of { happy_var_4 -> - case happyOut44 happy_x_5 of { happy_var_5 -> - case happyOut45 happy_x_6 of { happy_var_6 -> - happyIn33 - (let (s,n,t) = happy_var_6 in HsForImp happy_var_1 happy_var_4 happy_var_5 s n t - ) `HappyStk` happyRest}}}} - -happyReduce_80 = happyReduce 5# 29# happyReduction_80 -happyReduction_80 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut43 happy_x_4 of { happy_var_4 -> - case happyOut45 happy_x_5 of { happy_var_5 -> - happyIn33 - (let (s,n,t) = happy_var_5 in HsForExp happy_var_1 happy_var_4 s n t - ) `HappyStk` happyRest}}} - -happyReduce_81 = happySpecReduce_1 29# happyReduction_81 -happyReduction_81 happy_x_1 - = case happyOut38 happy_x_1 of { happy_var_1 -> - happyIn33 - (happy_var_1 - )} - -happyReduce_82 = happySpecReduce_1 30# happyReduction_82 -happyReduction_82 happy_x_1 - = happyIn34 - (DataType - ) - -happyReduce_83 = happySpecReduce_1 30# happyReduction_83 -happyReduction_83 happy_x_1 - = happyIn34 - (NewType - ) - -happyReduce_84 = happySpecReduce_1 31# happyReduction_84 -happyReduction_84 happy_x_1 - = case happyOut54 happy_x_1 of { happy_var_1 -> - happyIn35 - (reverse happy_var_1 - )} - -happyReduce_85 = happySpecReduce_1 31# happyReduction_85 -happyReduction_85 happy_x_1 - = case happyOut47 happy_x_1 of { happy_var_1 -> - happyIn35 - ([happy_var_1] - )} - -happyReduce_86 = happySpecReduce_0 31# happyReduction_86 -happyReduction_86 = happyIn35 - ([] - ) - -happyReduce_87 = happyMonadReduce 3# 32# happyReduction_87 -happyReduction_87 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut37 happy_x_2 of { happy_var_2 -> - ( checkRevDecls happy_var_2)} - ) (\r -> happyReturn (happyIn36 r)) - -happyReduce_88 = happySpecReduce_1 32# happyReduction_88 -happyReduction_88 happy_x_1 - = happyIn36 - ([] - ) - -happyReduce_89 = happySpecReduce_3 33# happyReduction_89 -happyReduction_89 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_90 = happySpecReduce_1 33# happyReduction_90 -happyReduction_90 happy_x_1 - = case happyOut38 happy_x_1 of { happy_var_1 -> - happyIn37 - ([happy_var_1] - )} - -happyReduce_91 = happySpecReduce_1 34# happyReduction_91 -happyReduction_91 happy_x_1 - = case happyOut40 happy_x_1 of { happy_var_1 -> - happyIn38 - (happy_var_1 - )} - -happyReduce_92 = happySpecReduce_1 34# happyReduction_92 -happyReduction_92 happy_x_1 - = case happyOut27 happy_x_1 of { happy_var_1 -> - happyIn38 - (happy_var_1 - )} - -happyReduce_93 = happySpecReduce_1 34# happyReduction_93 -happyReduction_93 happy_x_1 - = case happyOut94 happy_x_1 of { happy_var_1 -> - happyIn38 - (happy_var_1 - )} - -happyReduce_94 = happySpecReduce_3 35# happyReduction_94 -happyReduction_94 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut36 happy_x_2 of { happy_var_2 -> - happyIn39 - (happy_var_2 - )} - -happyReduce_95 = happySpecReduce_3 35# happyReduction_95 -happyReduction_95 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut36 happy_x_2 of { happy_var_2 -> - happyIn39 - (happy_var_2 - )} - -happyReduce_96 = happyReduce 4# 36# happyReduction_96 -happyReduction_96 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut42 happy_x_2 of { happy_var_2 -> - case happyOut52 happy_x_4 of { happy_var_4 -> - happyIn40 - (HsTypeSig happy_var_1 (reverse happy_var_2) happy_var_4 - ) `HappyStk` happyRest}}} - -happyReduce_97 = happySpecReduce_1 37# happyReduction_97 -happyReduction_97 happy_x_1 - = case happyOut39 happy_x_1 of { happy_var_1 -> - happyIn41 - (HsBDecls happy_var_1 - )} - -happyReduce_98 = happySpecReduce_3 37# happyReduction_98 -happyReduction_98 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut141 happy_x_2 of { happy_var_2 -> - happyIn41 - (HsIPBinds happy_var_2 - )} - -happyReduce_99 = happySpecReduce_3 37# happyReduction_99 -happyReduction_99 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut141 happy_x_2 of { happy_var_2 -> - happyIn41 - (HsIPBinds happy_var_2 - )} - -happyReduce_100 = happySpecReduce_3 38# happyReduction_100 -happyReduction_100 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut42 happy_x_1 of { happy_var_1 -> - case happyOut145 happy_x_3 of { happy_var_3 -> - happyIn42 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_101 = happyMonadReduce 1# 38# happyReduction_101 -happyReduction_101 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut147 happy_x_1 of { happy_var_1 -> - ( do { n <- checkUnQual happy_var_1; - return [n] })} - ) (\r -> happyReturn (happyIn42 r)) - -happyReduce_102 = happySpecReduce_1 39# happyReduction_102 -happyReduction_102 happy_x_1 - = happyIn43 - (StdCall - ) - -happyReduce_103 = happySpecReduce_1 39# happyReduction_103 -happyReduction_103 happy_x_1 - = happyIn43 - (CCall - ) - -happyReduce_104 = happySpecReduce_1 40# happyReduction_104 -happyReduction_104 happy_x_1 - = happyIn44 - (PlaySafe False - ) - -happyReduce_105 = happySpecReduce_1 40# happyReduction_105 -happyReduction_105 happy_x_1 - = happyIn44 - (PlayRisky - ) - -happyReduce_106 = happySpecReduce_1 40# happyReduction_106 -happyReduction_106 happy_x_1 - = happyIn44 - (PlaySafe True - ) - -happyReduce_107 = happySpecReduce_0 40# happyReduction_107 -happyReduction_107 = happyIn44 - (PlaySafe False - ) - -happyReduce_108 = happyReduce 4# 41# happyReduction_108 -happyReduction_108 (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 happyOut146 happy_x_2 of { happy_var_2 -> - case happyOut46 happy_x_4 of { happy_var_4 -> - happyIn45 - ((happy_var_1, happy_var_2, happy_var_4) - ) `HappyStk` happyRest}}} - -happyReduce_109 = happySpecReduce_3 41# happyReduction_109 -happyReduction_109 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut146 happy_x_1 of { happy_var_1 -> - case happyOut46 happy_x_3 of { happy_var_3 -> - happyIn45 - (("", happy_var_1, happy_var_3) - )}} - -happyReduce_110 = happySpecReduce_1 42# happyReduction_110 -happyReduction_110 happy_x_1 - = case happyOut48 happy_x_1 of { happy_var_1 -> - happyIn46 - (happy_var_1 - )} - -happyReduce_111 = happySpecReduce_3 42# happyReduction_111 -happyReduction_111 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut48 happy_x_1 of { happy_var_1 -> - case happyOut51 happy_x_2 of { happy_var_2 -> - case happyOut46 happy_x_3 of { happy_var_3 -> - happyIn46 - (HsTyInfix happy_var_1 happy_var_2 happy_var_3 - )}}} - -happyReduce_112 = happySpecReduce_3 42# happyReduction_112 -happyReduction_112 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut48 happy_x_1 of { happy_var_1 -> - case happyOut182 happy_x_2 of { happy_var_2 -> - case happyOut46 happy_x_3 of { happy_var_3 -> - happyIn46 - (HsTyInfix happy_var_1 happy_var_2 happy_var_3 - )}}} - -happyReduce_113 = happySpecReduce_3 42# happyReduction_113 -happyReduction_113 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut48 happy_x_1 of { happy_var_1 -> - case happyOut46 happy_x_3 of { happy_var_3 -> - happyIn46 - (HsTyFun happy_var_1 happy_var_3 - )}} - -happyReduce_114 = happySpecReduce_3 42# happyReduction_114 -happyReduction_114 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut48 happy_x_1 of { happy_var_1 -> - case happyOut48 happy_x_3 of { happy_var_3 -> - happyIn46 - (HsTyPred $ HsEqualP happy_var_1 happy_var_3 - )}} - -happyReduce_115 = happySpecReduce_3 43# happyReduction_115 -happyReduction_115 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut148 happy_x_1 of { happy_var_1 -> - case happyOut46 happy_x_3 of { happy_var_3 -> - happyIn47 - (HsTyPred $ HsIParam happy_var_1 happy_var_3 - )}} - -happyReduce_116 = happySpecReduce_1 43# happyReduction_116 -happyReduction_116 happy_x_1 - = case happyOut46 happy_x_1 of { happy_var_1 -> - happyIn47 - (happy_var_1 - )} - -happyReduce_117 = happySpecReduce_2 44# happyReduction_117 -happyReduction_117 happy_x_2 - happy_x_1 - = case happyOut48 happy_x_1 of { happy_var_1 -> - case happyOut49 happy_x_2 of { happy_var_2 -> - happyIn48 - (HsTyApp happy_var_1 happy_var_2 - )}} - -happyReduce_118 = happySpecReduce_1 44# happyReduction_118 -happyReduction_118 happy_x_1 - = case happyOut49 happy_x_1 of { happy_var_1 -> - happyIn48 - (happy_var_1 - )} - -happyReduce_119 = happySpecReduce_1 45# happyReduction_119 -happyReduction_119 happy_x_1 - = case happyOut50 happy_x_1 of { happy_var_1 -> - happyIn49 - (HsTyCon happy_var_1 - )} - -happyReduce_120 = happySpecReduce_1 45# happyReduction_120 -happyReduction_120 happy_x_1 - = case happyOut181 happy_x_1 of { happy_var_1 -> - happyIn49 - (HsTyVar happy_var_1 - )} - -happyReduce_121 = happySpecReduce_3 45# happyReduction_121 -happyReduction_121 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut54 happy_x_2 of { happy_var_2 -> - happyIn49 - (HsTyTuple Boxed (reverse happy_var_2) - )} - -happyReduce_122 = happySpecReduce_3 45# happyReduction_122 -happyReduction_122 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut55 happy_x_2 of { happy_var_2 -> - happyIn49 - (HsTyTuple Unboxed (reverse happy_var_2) - )} - -happyReduce_123 = happySpecReduce_3 45# happyReduction_123 -happyReduction_123 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut47 happy_x_2 of { happy_var_2 -> - happyIn49 - (HsTyApp list_tycon happy_var_2 - )} - -happyReduce_124 = happySpecReduce_3 45# happyReduction_124 -happyReduction_124 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut52 happy_x_2 of { happy_var_2 -> - happyIn49 - (happy_var_2 - )} - -happyReduce_125 = happyReduce 5# 45# 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) - = case happyOut52 happy_x_2 of { happy_var_2 -> - case happyOut80 happy_x_4 of { happy_var_4 -> - happyIn49 - (HsTyKind happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_126 = happySpecReduce_1 46# happyReduction_126 -happyReduction_126 happy_x_1 - = case happyOut164 happy_x_1 of { happy_var_1 -> - happyIn50 - (happy_var_1 - )} - -happyReduce_127 = happySpecReduce_2 46# happyReduction_127 -happyReduction_127 happy_x_2 - happy_x_1 - = happyIn50 - (unit_tycon_name - ) - -happyReduce_128 = happySpecReduce_3 46# happyReduction_128 -happyReduction_128 happy_x_3 - happy_x_2 - happy_x_1 - = happyIn50 - (fun_tycon_name - ) - -happyReduce_129 = happySpecReduce_2 46# happyReduction_129 -happyReduction_129 happy_x_2 - happy_x_1 - = happyIn50 - (list_tycon_name - ) - -happyReduce_130 = happySpecReduce_3 46# happyReduction_130 -happyReduction_130 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut111 happy_x_2 of { happy_var_2 -> - happyIn50 - (tuple_tycon_name happy_var_2 - )} - -happyReduce_131 = happySpecReduce_1 47# happyReduction_131 -happyReduction_131 happy_x_1 - = case happyOut155 happy_x_1 of { happy_var_1 -> - happyIn51 - (happy_var_1 - )} - -happyReduce_132 = happyReduce 4# 48# happyReduction_132 -happyReduction_132 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut56 happy_x_2 of { happy_var_2 -> - case happyOut52 happy_x_4 of { happy_var_4 -> - happyIn52 - (mkHsTyForall (Just happy_var_2) [] happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_133 = happySpecReduce_3 48# happyReduction_133 -happyReduction_133 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut53 happy_x_1 of { happy_var_1 -> - case happyOut47 happy_x_3 of { happy_var_3 -> - happyIn52 - (mkHsTyForall Nothing happy_var_1 happy_var_3 - )}} - -happyReduce_134 = happySpecReduce_1 48# happyReduction_134 -happyReduction_134 happy_x_1 - = case happyOut47 happy_x_1 of { happy_var_1 -> - happyIn52 - (happy_var_1 - )} - -happyReduce_135 = happyMonadReduce 1# 49# happyReduction_135 -happyReduction_135 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut48 happy_x_1 of { happy_var_1 -> - ( checkContext happy_var_1)} - ) (\r -> happyReturn (happyIn53 r)) - -happyReduce_136 = happyMonadReduce 3# 49# happyReduction_136 -happyReduction_136 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut48 happy_x_1 of { happy_var_1 -> - case happyOut48 happy_x_3 of { happy_var_3 -> - ( checkContext (HsTyPred $ HsEqualP happy_var_1 happy_var_3))}} - ) (\r -> happyReturn (happyIn53 r)) - -happyReduce_137 = happySpecReduce_3 50# happyReduction_137 -happyReduction_137 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut55 happy_x_1 of { happy_var_1 -> - case happyOut47 happy_x_3 of { happy_var_3 -> - happyIn54 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_138 = happySpecReduce_1 51# happyReduction_138 -happyReduction_138 happy_x_1 - = case happyOut47 happy_x_1 of { happy_var_1 -> - happyIn55 - ([happy_var_1] - )} - -happyReduce_139 = happySpecReduce_3 51# happyReduction_139 -happyReduction_139 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut55 happy_x_1 of { happy_var_1 -> - case happyOut47 happy_x_3 of { happy_var_3 -> - happyIn55 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_140 = happySpecReduce_2 52# happyReduction_140 -happyReduction_140 happy_x_2 - happy_x_1 - = case happyOut56 happy_x_1 of { happy_var_1 -> - case happyOut57 happy_x_2 of { happy_var_2 -> - happyIn56 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_141 = happySpecReduce_0 52# happyReduction_141 -happyReduction_141 = happyIn56 - ([] - ) - -happyReduce_142 = happySpecReduce_1 53# happyReduction_142 -happyReduction_142 happy_x_1 - = case happyOut181 happy_x_1 of { happy_var_1 -> - happyIn57 - (HsUnkindedVar happy_var_1 - )} - -happyReduce_143 = happyReduce 5# 53# happyReduction_143 -happyReduction_143 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut181 happy_x_2 of { happy_var_2 -> - case happyOut80 happy_x_4 of { happy_var_4 -> - happyIn57 - (HsKindedVar happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_144 = happySpecReduce_2 54# happyReduction_144 -happyReduction_144 happy_x_2 - happy_x_1 - = case happyOut58 happy_x_1 of { happy_var_1 -> - case happyOut181 happy_x_2 of { happy_var_2 -> - happyIn58 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_145 = happySpecReduce_0 54# happyReduction_145 -happyReduction_145 = happyIn58 - ([] - ) - -happyReduce_146 = happySpecReduce_0 55# happyReduction_146 -happyReduction_146 = happyIn59 - ([] - ) - -happyReduce_147 = happySpecReduce_2 55# happyReduction_147 -happyReduction_147 happy_x_2 - happy_x_1 - = case happyOut60 happy_x_2 of { happy_var_2 -> - happyIn59 - (reverse happy_var_2 - )} - -happyReduce_148 = happySpecReduce_3 56# happyReduction_148 -happyReduction_148 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_149 = happySpecReduce_1 56# happyReduction_149 -happyReduction_149 happy_x_1 - = case happyOut61 happy_x_1 of { happy_var_1 -> - happyIn60 - ([happy_var_1] - )} - -happyReduce_150 = happySpecReduce_3 57# happyReduction_150 -happyReduction_150 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut58 happy_x_1 of { happy_var_1 -> - case happyOut58 happy_x_3 of { happy_var_3 -> - happyIn61 - (HsFunDep (reverse happy_var_1) (reverse happy_var_3) - )}} - -happyReduce_151 = happySpecReduce_3 58# happyReduction_151 -happyReduction_151 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut63 happy_x_2 of { happy_var_2 -> - happyIn62 - (happy_var_2 - )} - -happyReduce_152 = happySpecReduce_3 58# happyReduction_152 -happyReduction_152 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut63 happy_x_2 of { happy_var_2 -> - happyIn62 - (happy_var_2 - )} - -happyReduce_153 = happySpecReduce_3 59# happyReduction_153 -happyReduction_153 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut64 happy_x_2 of { happy_var_2 -> - happyIn63 - (happy_var_2 - )} - -happyReduce_154 = happySpecReduce_3 60# happyReduction_154 -happyReduction_154 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut64 happy_x_1 of { happy_var_1 -> - case happyOut65 happy_x_3 of { happy_var_3 -> - happyIn64 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_155 = happySpecReduce_1 60# happyReduction_155 -happyReduction_155 happy_x_1 - = case happyOut65 happy_x_1 of { happy_var_1 -> - happyIn64 - ([happy_var_1] - )} - -happyReduce_156 = happyMonadReduce 4# 61# happyReduction_156 -happyReduction_156 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut150 happy_x_2 of { happy_var_2 -> - case happyOut52 happy_x_4 of { happy_var_4 -> - ( do { c <- checkUnQual happy_var_2; - return $ HsGadtDecl happy_var_1 c happy_var_4 })}}} - ) (\r -> happyReturn (happyIn65 r)) - -happyReduce_157 = happySpecReduce_0 62# happyReduction_157 -happyReduction_157 = happyIn66 - ([] - ) - -happyReduce_158 = happySpecReduce_2 62# happyReduction_158 -happyReduction_158 happy_x_2 - happy_x_1 - = case happyOut67 happy_x_2 of { happy_var_2 -> - happyIn66 - (happy_var_2 - )} - -happyReduce_159 = happySpecReduce_3 63# happyReduction_159 -happyReduction_159 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut67 happy_x_1 of { happy_var_1 -> - case happyOut68 happy_x_3 of { happy_var_3 -> - happyIn67 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_160 = happySpecReduce_1 63# happyReduction_160 -happyReduction_160 happy_x_1 - = case happyOut68 happy_x_1 of { happy_var_1 -> - happyIn67 - ([happy_var_1] - )} - -happyReduce_161 = happyReduce 5# 64# happyReduction_161 -happyReduction_161 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut69 happy_x_2 of { happy_var_2 -> - case happyOut53 happy_x_3 of { happy_var_3 -> - case happyOut70 happy_x_5 of { happy_var_5 -> - happyIn68 - (HsQualConDecl happy_var_1 happy_var_2 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}}} - -happyReduce_162 = happySpecReduce_3 64# happyReduction_162 -happyReduction_162 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut69 happy_x_2 of { happy_var_2 -> - case happyOut70 happy_x_3 of { happy_var_3 -> - happyIn68 - (HsQualConDecl happy_var_1 happy_var_2 [] happy_var_3 - )}}} - -happyReduce_163 = happySpecReduce_3 65# happyReduction_163 -happyReduction_163 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut56 happy_x_2 of { happy_var_2 -> - happyIn69 - (happy_var_2 - )} - -happyReduce_164 = happySpecReduce_0 65# happyReduction_164 -happyReduction_164 = happyIn69 - ([] - ) - -happyReduce_165 = happySpecReduce_1 66# happyReduction_165 -happyReduction_165 happy_x_1 - = case happyOut71 happy_x_1 of { happy_var_1 -> - happyIn70 - (HsConDecl (fst happy_var_1) (snd happy_var_1) - )} - -happyReduce_166 = happySpecReduce_3 66# happyReduction_166 -happyReduction_166 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut74 happy_x_1 of { happy_var_1 -> - case happyOut154 happy_x_2 of { happy_var_2 -> - case happyOut74 happy_x_3 of { happy_var_3 -> - happyIn70 - (HsConDecl happy_var_2 [happy_var_1,happy_var_3] - )}}} - -happyReduce_167 = happySpecReduce_3 66# happyReduction_167 -happyReduction_167 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut149 happy_x_1 of { happy_var_1 -> - happyIn70 - (HsRecDecl happy_var_1 [] - )} - -happyReduce_168 = happyReduce 4# 66# happyReduction_168 -happyReduction_168 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut149 happy_x_1 of { happy_var_1 -> - case happyOut75 happy_x_3 of { happy_var_3 -> - happyIn70 - (HsRecDecl happy_var_1 (reverse happy_var_3) - ) `HappyStk` happyRest}} - -happyReduce_169 = happyMonadReduce 1# 67# happyReduction_169 -happyReduction_169 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut48 happy_x_1 of { happy_var_1 -> - ( do { (c,ts) <- splitTyConApp happy_var_1; - return (c,map HsUnBangedTy ts) })} - ) (\r -> happyReturn (happyIn71 r)) - -happyReduce_170 = happySpecReduce_1 67# happyReduction_170 -happyReduction_170 happy_x_1 - = case happyOut72 happy_x_1 of { happy_var_1 -> - happyIn71 - (happy_var_1 - )} - -happyReduce_171 = happyMonadReduce 3# 68# happyReduction_171 -happyReduction_171 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut48 happy_x_1 of { happy_var_1 -> - case happyOut49 happy_x_3 of { happy_var_3 -> - ( do { (c,ts) <- splitTyConApp happy_var_1; - return (c,map HsUnBangedTy ts++ - [HsBangedTy happy_var_3]) })}} - ) (\r -> happyReturn (happyIn72 r)) - -happyReduce_172 = happySpecReduce_2 68# happyReduction_172 -happyReduction_172 happy_x_2 - happy_x_1 - = case happyOut72 happy_x_1 of { happy_var_1 -> - case happyOut73 happy_x_2 of { happy_var_2 -> - happyIn72 - ((fst happy_var_1, snd happy_var_1 ++ [happy_var_2] ) - )}} - -happyReduce_173 = happySpecReduce_1 69# happyReduction_173 -happyReduction_173 happy_x_1 - = case happyOut49 happy_x_1 of { happy_var_1 -> - happyIn73 - (HsUnBangedTy happy_var_1 - )} - -happyReduce_174 = happySpecReduce_2 69# happyReduction_174 -happyReduction_174 happy_x_2 - happy_x_1 - = case happyOut49 happy_x_2 of { happy_var_2 -> - happyIn73 - (HsBangedTy happy_var_2 - )} - -happyReduce_175 = happySpecReduce_1 70# happyReduction_175 -happyReduction_175 happy_x_1 - = case happyOut48 happy_x_1 of { happy_var_1 -> - happyIn74 - (HsUnBangedTy happy_var_1 - )} - -happyReduce_176 = happySpecReduce_2 70# happyReduction_176 -happyReduction_176 happy_x_2 - happy_x_1 - = case happyOut49 happy_x_2 of { happy_var_2 -> - happyIn74 - (HsBangedTy happy_var_2 - )} - -happyReduce_177 = happySpecReduce_3 71# happyReduction_177 -happyReduction_177 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut75 happy_x_1 of { happy_var_1 -> - case happyOut76 happy_x_3 of { happy_var_3 -> - happyIn75 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_178 = happySpecReduce_1 71# happyReduction_178 -happyReduction_178 happy_x_1 - = case happyOut76 happy_x_1 of { happy_var_1 -> - happyIn75 - ([happy_var_1] - )} - -happyReduce_179 = happySpecReduce_3 72# happyReduction_179 -happyReduction_179 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut42 happy_x_1 of { happy_var_1 -> - case happyOut77 happy_x_3 of { happy_var_3 -> - happyIn76 - ((reverse happy_var_1, happy_var_3) - )}} - -happyReduce_180 = happySpecReduce_1 73# happyReduction_180 -happyReduction_180 happy_x_1 - = case happyOut52 happy_x_1 of { happy_var_1 -> - happyIn77 - (HsUnBangedTy happy_var_1 - )} - -happyReduce_181 = happySpecReduce_2 73# happyReduction_181 -happyReduction_181 happy_x_2 - happy_x_1 - = case happyOut49 happy_x_2 of { happy_var_2 -> - happyIn77 - (HsBangedTy happy_var_2 - )} - -happyReduce_182 = happySpecReduce_0 74# happyReduction_182 -happyReduction_182 = happyIn78 - ([] - ) - -happyReduce_183 = happySpecReduce_2 74# happyReduction_183 -happyReduction_183 happy_x_2 - happy_x_1 - = case happyOut180 happy_x_2 of { happy_var_2 -> - happyIn78 - ([happy_var_2] - )} - -happyReduce_184 = happySpecReduce_3 74# happyReduction_184 -happyReduction_184 happy_x_3 - happy_x_2 - happy_x_1 - = happyIn78 - ([] - ) - -happyReduce_185 = happyReduce 4# 74# happyReduction_185 -happyReduction_185 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut79 happy_x_3 of { happy_var_3 -> - happyIn78 - (reverse happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_186 = happySpecReduce_3 75# happyReduction_186 -happyReduction_186 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut79 happy_x_1 of { happy_var_1 -> - case happyOut180 happy_x_3 of { happy_var_3 -> - happyIn79 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_187 = happySpecReduce_1 75# happyReduction_187 -happyReduction_187 happy_x_1 - = case happyOut180 happy_x_1 of { happy_var_1 -> - happyIn79 - ([happy_var_1] - )} - -happyReduce_188 = happySpecReduce_1 76# happyReduction_188 -happyReduction_188 happy_x_1 - = case happyOut81 happy_x_1 of { happy_var_1 -> - happyIn80 - (happy_var_1 - )} - -happyReduce_189 = happySpecReduce_3 76# happyReduction_189 -happyReduction_189 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut81 happy_x_1 of { happy_var_1 -> - case happyOut80 happy_x_3 of { happy_var_3 -> - happyIn80 - (HsKindFn happy_var_1 happy_var_3 - )}} - -happyReduce_190 = happySpecReduce_1 77# happyReduction_190 -happyReduction_190 happy_x_1 - = happyIn81 - (HsKindStar - ) - -happyReduce_191 = happySpecReduce_1 77# happyReduction_191 -happyReduction_191 happy_x_1 - = happyIn81 - (HsKindBang - ) - -happyReduce_192 = happySpecReduce_3 77# happyReduction_192 -happyReduction_192 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut80 happy_x_2 of { happy_var_2 -> - happyIn81 - (happy_var_2 - )} - -happyReduce_193 = happySpecReduce_0 78# happyReduction_193 -happyReduction_193 = happyIn82 - (Nothing - ) - -happyReduce_194 = happySpecReduce_2 78# happyReduction_194 -happyReduction_194 happy_x_2 - happy_x_1 - = case happyOut80 happy_x_2 of { happy_var_2 -> - happyIn82 - (Just happy_var_2 - )} - -happyReduce_195 = happyMonadReduce 2# 79# happyReduction_195 -happyReduction_195 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut84 happy_x_2 of { happy_var_2 -> - ( checkClassBody happy_var_2)} - ) (\r -> happyReturn (happyIn83 r)) - -happyReduce_196 = happySpecReduce_0 79# happyReduction_196 -happyReduction_196 = happyIn83 - ([] - ) - -happyReduce_197 = happySpecReduce_3 80# happyReduction_197 -happyReduction_197 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut85 happy_x_2 of { happy_var_2 -> - happyIn84 - (happy_var_2 - )} - -happyReduce_198 = happySpecReduce_3 80# happyReduction_198 -happyReduction_198 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut85 happy_x_2 of { happy_var_2 -> - happyIn84 - (happy_var_2 - )} - -happyReduce_199 = happyMonadReduce 3# 81# happyReduction_199 -happyReduction_199 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut86 happy_x_2 of { happy_var_2 -> - ( checkRevClsDecls happy_var_2)} - ) (\r -> happyReturn (happyIn85 r)) - -happyReduce_200 = happySpecReduce_1 81# happyReduction_200 -happyReduction_200 happy_x_1 - = happyIn85 - ([] - ) - -happyReduce_201 = happySpecReduce_3 82# happyReduction_201 -happyReduction_201 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut86 happy_x_1 of { happy_var_1 -> - case happyOut87 happy_x_3 of { happy_var_3 -> - happyIn86 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_202 = happySpecReduce_1 82# happyReduction_202 -happyReduction_202 happy_x_1 - = case happyOut87 happy_x_1 of { happy_var_1 -> - happyIn86 - ([happy_var_1] - )} - -happyReduce_203 = happySpecReduce_1 83# happyReduction_203 -happyReduction_203 happy_x_1 - = case happyOut38 happy_x_1 of { happy_var_1 -> - happyIn87 - (HsClsDecl happy_var_1 - )} - -happyReduce_204 = happySpecReduce_1 83# happyReduction_204 -happyReduction_204 happy_x_1 - = case happyOut88 happy_x_1 of { happy_var_1 -> - happyIn87 - (happy_var_1 - )} - -happyReduce_205 = happyMonadReduce 4# 84# happyReduction_205 -happyReduction_205 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut47 happy_x_3 of { happy_var_3 -> - case happyOut82 happy_x_4 of { happy_var_4 -> - ( do { (c,ts) <- checkSimpleType happy_var_3; - return (HsClsTyFam happy_var_1 c ts happy_var_4) })}}} - ) (\r -> happyReturn (happyIn88 r)) - -happyReduce_206 = happyReduce 5# 84# happyReduction_206 -happyReduction_206 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut46 happy_x_3 of { happy_var_3 -> - case happyOut52 happy_x_5 of { happy_var_5 -> - happyIn88 - (HsClsTyDef happy_var_1 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_207 = happyMonadReduce 4# 84# happyReduction_207 -happyReduction_207 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut52 happy_x_3 of { happy_var_3 -> - case happyOut82 happy_x_4 of { happy_var_4 -> - ( do { (cs,c,t) <- checkDataHeader happy_var_3; - return (HsClsDataFam happy_var_1 cs c t happy_var_4) })}}} - ) (\r -> happyReturn (happyIn88 r)) - -happyReduce_208 = happyMonadReduce 4# 85# happyReduction_208 -happyReduction_208 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut90 happy_x_3 of { happy_var_3 -> - ( checkInstBody happy_var_3)} - ) (\r -> happyReturn (happyIn89 r)) - -happyReduce_209 = happyMonadReduce 4# 85# happyReduction_209 -happyReduction_209 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut90 happy_x_3 of { happy_var_3 -> - ( checkInstBody happy_var_3)} - ) (\r -> happyReturn (happyIn89 r)) - -happyReduce_210 = happySpecReduce_0 85# happyReduction_210 -happyReduction_210 = happyIn89 - ([] - ) - -happyReduce_211 = happyMonadReduce 3# 86# happyReduction_211 -happyReduction_211 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut91 happy_x_2 of { happy_var_2 -> - ( checkRevInstDecls happy_var_2)} - ) (\r -> happyReturn (happyIn90 r)) - -happyReduce_212 = happySpecReduce_1 86# happyReduction_212 -happyReduction_212 happy_x_1 - = happyIn90 - ([] - ) - -happyReduce_213 = happySpecReduce_3 87# happyReduction_213 -happyReduction_213 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut91 happy_x_1 of { happy_var_1 -> - case happyOut92 happy_x_3 of { happy_var_3 -> - happyIn91 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_214 = happySpecReduce_1 87# happyReduction_214 -happyReduction_214 happy_x_1 - = case happyOut92 happy_x_1 of { happy_var_1 -> - happyIn91 - ([happy_var_1] - )} - -happyReduce_215 = happySpecReduce_1 88# happyReduction_215 -happyReduction_215 happy_x_1 - = case happyOut94 happy_x_1 of { happy_var_1 -> - happyIn92 - (HsInsDecl happy_var_1 - )} - -happyReduce_216 = happySpecReduce_1 88# happyReduction_216 -happyReduction_216 happy_x_1 - = case happyOut93 happy_x_1 of { happy_var_1 -> - happyIn92 - (happy_var_1 - )} - -happyReduce_217 = happyMonadReduce 5# 89# happyReduction_217 -happyReduction_217 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut46 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut52 happy_x_5 of { happy_var_5 -> - ( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns - return (HsInsType happy_var_1 happy_var_3 happy_var_5) })}}}} - ) (\r -> happyReturn (happyIn93 r)) - -happyReduce_218 = happyMonadReduce 5# 89# happyReduction_218 -happyReduction_218 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut34 happy_x_2 of { happy_var_2 -> - case happyOut52 happy_x_3 of { happy_var_3 -> - case happyOut66 happy_x_4 of { happy_var_4 -> - case happyOut78 happy_x_5 of { happy_var_5 -> - ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; - checkDataOrNew happy_var_2 happy_var_4; - return (HsInsData happy_var_1 happy_var_2 happy_var_3 (reverse happy_var_4) happy_var_5) })}}}}} - ) (\r -> happyReturn (happyIn93 r)) - -happyReduce_219 = happyMonadReduce 6# 89# happyReduction_219 -happyReduction_219 (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 happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut34 happy_x_2 of { happy_var_2 -> - case happyOut52 happy_x_3 of { happy_var_3 -> - case happyOut82 happy_x_4 of { happy_var_4 -> - case happyOut62 happy_x_6 of { happy_var_6 -> - ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; - checkDataOrNew happy_var_2 happy_var_6; - return (HsInsGData happy_var_1 happy_var_2 happy_var_3 happy_var_4 (reverse happy_var_6)) })}}}}} - ) (\r -> happyReturn (happyIn93 r)) - -happyReduce_220 = happyMonadReduce 4# 90# happyReduction_220 -happyReduction_220 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut102 happy_x_2 of { happy_var_2 -> - case happyOut96 happy_x_3 of { happy_var_3 -> - case happyOut95 happy_x_4 of { happy_var_4 -> - ( checkValDef happy_var_1 happy_var_2 happy_var_3 happy_var_4)}}}} - ) (\r -> happyReturn (happyIn94 r)) - -happyReduce_221 = happySpecReduce_2 91# happyReduction_221 -happyReduction_221 happy_x_2 - happy_x_1 - = case happyOut41 happy_x_2 of { happy_var_2 -> - happyIn95 - (happy_var_2 - )} - -happyReduce_222 = happySpecReduce_0 91# happyReduction_222 -happyReduction_222 = happyIn95 - (HsBDecls [] - ) - -happyReduce_223 = happyMonadReduce 2# 92# happyReduction_223 -happyReduction_223 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut99 happy_x_2 of { happy_var_2 -> - ( do { e <- checkExpr happy_var_2; - return (HsUnGuardedRhs e) })} - ) (\r -> happyReturn (happyIn96 r)) - -happyReduce_224 = happySpecReduce_1 92# happyReduction_224 -happyReduction_224 happy_x_1 - = case happyOut97 happy_x_1 of { happy_var_1 -> - happyIn96 - (HsGuardedRhss (reverse happy_var_1) - )} - -happyReduce_225 = happySpecReduce_2 93# happyReduction_225 -happyReduction_225 happy_x_2 - happy_x_1 - = case happyOut97 happy_x_1 of { happy_var_1 -> - case happyOut98 happy_x_2 of { happy_var_2 -> - happyIn97 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_226 = happySpecReduce_1 93# happyReduction_226 -happyReduction_226 happy_x_1 - = case happyOut98 happy_x_1 of { happy_var_1 -> - happyIn97 - ([happy_var_1] - )} - -happyReduce_227 = happyMonadReduce 5# 94# happyReduction_227 -happyReduction_227 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut126 happy_x_3 of { happy_var_3 -> - case happyOut99 happy_x_5 of { happy_var_5 -> - ( do { e <- checkExpr happy_var_5; - return (HsGuardedRhs happy_var_1 (reverse happy_var_3) e) })}}} - ) (\r -> happyReturn (happyIn98 r)) - -happyReduce_228 = happyReduce 4# 95# happyReduction_228 -happyReduction_228 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut102 happy_x_1 of { happy_var_1 -> - case happyOut174 happy_x_3 of { happy_var_3 -> - case happyOut52 happy_x_4 of { happy_var_4 -> - happyIn99 - (HsExpTypeSig happy_var_3 happy_var_1 happy_var_4 - ) `HappyStk` happyRest}}} - -happyReduce_229 = happySpecReduce_1 95# happyReduction_229 -happyReduction_229 happy_x_1 - = case happyOut100 happy_x_1 of { happy_var_1 -> - happyIn99 - (happy_var_1 - )} - -happyReduce_230 = happySpecReduce_2 95# happyReduction_230 -happyReduction_230 happy_x_2 - happy_x_1 - = case happyOut102 happy_x_1 of { happy_var_1 -> - case happyOut157 happy_x_2 of { happy_var_2 -> - happyIn99 - (HsPostOp happy_var_1 happy_var_2 - )}} - -happyReduce_231 = happySpecReduce_1 96# happyReduction_231 -happyReduction_231 happy_x_1 - = case happyOut101 happy_x_1 of { happy_var_1 -> - happyIn100 - (happy_var_1 - )} - -happyReduce_232 = happySpecReduce_1 96# happyReduction_232 -happyReduction_232 happy_x_1 - = case happyOut102 happy_x_1 of { happy_var_1 -> - happyIn100 - (happy_var_1 - )} - -happyReduce_233 = happySpecReduce_3 97# happyReduction_233 -happyReduction_233 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut102 happy_x_1 of { happy_var_1 -> - case happyOut157 happy_x_2 of { happy_var_2 -> - case happyOut103 happy_x_3 of { happy_var_3 -> - happyIn101 - (HsInfixApp happy_var_1 happy_var_2 happy_var_3 - )}}} - -happyReduce_234 = happySpecReduce_1 97# happyReduction_234 -happyReduction_234 happy_x_1 - = case happyOut103 happy_x_1 of { happy_var_1 -> - happyIn101 - (happy_var_1 - )} - -happyReduce_235 = happySpecReduce_3 98# happyReduction_235 -happyReduction_235 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut102 happy_x_1 of { happy_var_1 -> - case happyOut157 happy_x_2 of { happy_var_2 -> - case happyOut104 happy_x_3 of { happy_var_3 -> - happyIn102 - (HsInfixApp happy_var_1 happy_var_2 happy_var_3 - )}}} - -happyReduce_236 = happySpecReduce_1 98# happyReduction_236 -happyReduction_236 happy_x_1 - = case happyOut123 happy_x_1 of { happy_var_1 -> - happyIn102 - (happy_var_1 - )} - -happyReduce_237 = happySpecReduce_1 98# happyReduction_237 -happyReduction_237 happy_x_1 - = case happyOut104 happy_x_1 of { happy_var_1 -> - happyIn102 - (happy_var_1 - )} - -happyReduce_238 = happyReduce 5# 99# happyReduction_238 -happyReduction_238 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_2 of { happy_var_2 -> - case happyOut106 happy_x_3 of { happy_var_3 -> - case happyOut99 happy_x_5 of { happy_var_5 -> - happyIn103 - (HsLambda happy_var_2 (reverse happy_var_3) happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_239 = happyReduce 4# 99# happyReduction_239 -happyReduction_239 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut41 happy_x_2 of { happy_var_2 -> - case happyOut99 happy_x_4 of { happy_var_4 -> - happyIn103 - (HsLet happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_240 = happyReduce 6# 99# happyReduction_240 -happyReduction_240 (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 happyOut99 happy_x_2 of { happy_var_2 -> - case happyOut99 happy_x_4 of { happy_var_4 -> - case happyOut99 happy_x_6 of { happy_var_6 -> - happyIn103 - (HsIf happy_var_2 happy_var_4 happy_var_6 - ) `HappyStk` happyRest}}} - -happyReduce_241 = happyReduce 4# 100# happyReduction_241 -happyReduction_241 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut99 happy_x_2 of { happy_var_2 -> - case happyOut129 happy_x_4 of { happy_var_4 -> - happyIn104 - (HsCase happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_242 = happySpecReduce_2 100# happyReduction_242 -happyReduction_242 happy_x_2 - happy_x_1 - = case happyOut105 happy_x_2 of { happy_var_2 -> - happyIn104 - (HsNegApp happy_var_2 - )} - -happyReduce_243 = happySpecReduce_2 100# happyReduction_243 -happyReduction_243 happy_x_2 - happy_x_1 - = case happyOut137 happy_x_2 of { happy_var_2 -> - happyIn104 - (HsDo happy_var_2 - )} - -happyReduce_244 = happySpecReduce_2 100# happyReduction_244 -happyReduction_244 happy_x_2 - happy_x_1 - = case happyOut137 happy_x_2 of { happy_var_2 -> - happyIn104 - (HsMDo happy_var_2 - )} - -happyReduce_245 = happySpecReduce_1 100# happyReduction_245 -happyReduction_245 happy_x_1 - = case happyOut105 happy_x_1 of { happy_var_1 -> - happyIn104 - (happy_var_1 - )} - -happyReduce_246 = happySpecReduce_2 101# happyReduction_246 -happyReduction_246 happy_x_2 - happy_x_1 - = case happyOut105 happy_x_1 of { happy_var_1 -> - case happyOut108 happy_x_2 of { happy_var_2 -> - happyIn105 - (HsApp happy_var_1 happy_var_2 - )}} - -happyReduce_247 = happySpecReduce_1 101# happyReduction_247 -happyReduction_247 happy_x_1 - = case happyOut108 happy_x_1 of { happy_var_1 -> - happyIn105 - (happy_var_1 - )} - -happyReduce_248 = happySpecReduce_2 102# happyReduction_248 -happyReduction_248 happy_x_2 - happy_x_1 - = case happyOut106 happy_x_1 of { happy_var_1 -> - case happyOut107 happy_x_2 of { happy_var_2 -> - happyIn106 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_249 = happySpecReduce_1 102# happyReduction_249 -happyReduction_249 happy_x_1 - = case happyOut107 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_250 = happyMonadReduce 1# 103# happyReduction_250 -happyReduction_250 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut108 happy_x_1 of { happy_var_1 -> - ( checkPattern happy_var_1)} - ) (\r -> happyReturn (happyIn107 r)) - -happyReduce_251 = happyMonadReduce 3# 104# happyReduction_251 -happyReduction_251 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut147 happy_x_1 of { happy_var_1 -> - case happyOut108 happy_x_3 of { happy_var_3 -> - ( do { n <- checkUnQual happy_var_1; - return (HsAsPat n happy_var_3) })}} - ) (\r -> happyReturn (happyIn108 r)) - -happyReduce_252 = happyMonadReduce 3# 104# happyReduction_252 -happyReduction_252 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut147 happy_x_1 of { happy_var_1 -> - case happyOut108 happy_x_3 of { happy_var_3 -> - ( do { n <- checkUnQual happy_var_1; - return (HsCAsRP n happy_var_3) })}} - ) (\r -> happyReturn (happyIn108 r)) - -happyReduce_253 = happySpecReduce_2 104# happyReduction_253 -happyReduction_253 happy_x_2 - happy_x_1 - = case happyOut108 happy_x_2 of { happy_var_2 -> - happyIn108 - (HsIrrPat happy_var_2 - )} - -happyReduce_254 = happySpecReduce_1 104# happyReduction_254 -happyReduction_254 happy_x_1 - = case happyOut109 happy_x_1 of { happy_var_1 -> - happyIn108 - (happy_var_1 - )} - -happyReduce_255 = happyMonadReduce 3# 105# happyReduction_255 -happyReduction_255 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut109 happy_x_1 of { happy_var_1 -> - ( mkRecConstrOrUpdate happy_var_1 [])} - ) (\r -> happyReturn (happyIn109 r)) - -happyReduce_256 = happyMonadReduce 4# 105# happyReduction_256 -happyReduction_256 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut109 happy_x_1 of { happy_var_1 -> - case happyOut139 happy_x_3 of { happy_var_3 -> - ( mkRecConstrOrUpdate happy_var_1 (reverse happy_var_3))}} - ) (\r -> happyReturn (happyIn109 r)) - -happyReduce_257 = happySpecReduce_1 105# happyReduction_257 -happyReduction_257 happy_x_1 - = case happyOut110 happy_x_1 of { happy_var_1 -> - happyIn109 - (happy_var_1 - )} - -happyReduce_258 = happySpecReduce_1 106# happyReduction_258 -happyReduction_258 happy_x_1 - = case happyOut148 happy_x_1 of { happy_var_1 -> - happyIn110 - (HsIPVar happy_var_1 - )} - -happyReduce_259 = happySpecReduce_1 106# happyReduction_259 -happyReduction_259 happy_x_1 - = case happyOut147 happy_x_1 of { happy_var_1 -> - happyIn110 - (HsVar happy_var_1 - )} - -happyReduce_260 = happySpecReduce_1 106# happyReduction_260 -happyReduction_260 happy_x_1 - = case happyOut144 happy_x_1 of { happy_var_1 -> - happyIn110 - (happy_var_1 - )} - -happyReduce_261 = happySpecReduce_1 106# happyReduction_261 -happyReduction_261 happy_x_1 - = case happyOut173 happy_x_1 of { happy_var_1 -> - happyIn110 - (HsLit happy_var_1 - )} - -happyReduce_262 = happySpecReduce_3 106# happyReduction_262 -happyReduction_262 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut99 happy_x_2 of { happy_var_2 -> - happyIn110 - (HsParen happy_var_2 - )} - -happyReduce_263 = happySpecReduce_3 106# happyReduction_263 -happyReduction_263 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut112 happy_x_2 of { happy_var_2 -> - happyIn110 - (HsTuple (reverse happy_var_2) - )} - -happyReduce_264 = happySpecReduce_3 106# happyReduction_264 -happyReduction_264 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut124 happy_x_2 of { happy_var_2 -> - happyIn110 - (happy_var_2 - )} - -happyReduce_265 = happyReduce 4# 106# happyReduction_265 -happyReduction_265 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut158 happy_x_2 of { happy_var_2 -> - case happyOut100 happy_x_3 of { happy_var_3 -> - happyIn110 - (HsRightSection happy_var_2 happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_266 = happySpecReduce_1 106# happyReduction_266 -happyReduction_266 happy_x_1 - = happyIn110 - (HsWildCard - ) - -happyReduce_267 = happySpecReduce_3 106# happyReduction_267 -happyReduction_267 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut114 happy_x_2 of { happy_var_2 -> - happyIn110 - (happy_var_2 - )} - -happyReduce_268 = happySpecReduce_3 106# happyReduction_268 -happyReduction_268 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut113 happy_x_2 of { happy_var_2 -> - happyIn110 - (HsSeqRP $ reverse happy_var_2 - )} - -happyReduce_269 = happyReduce 5# 106# happyReduction_269 -happyReduction_269 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut99 happy_x_2 of { happy_var_2 -> - case happyOut126 happy_x_4 of { happy_var_4 -> - happyIn110 - (HsGuardRP happy_var_2 $ reverse happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_270 = happySpecReduce_1 106# happyReduction_270 -happyReduction_270 happy_x_1 - = case happyOut115 happy_x_1 of { happy_var_1 -> - happyIn110 - (happy_var_1 - )} - -happyReduce_271 = happySpecReduce_1 106# happyReduction_271 -happyReduction_271 happy_x_1 - = case happyOutTok happy_x_1 of { (THIdEscape happy_var_1) -> - happyIn110 - (HsSpliceExp $ HsIdSplice happy_var_1 - )} - -happyReduce_272 = happyMonadReduce 3# 106# happyReduction_272 -happyReduction_272 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut99 happy_x_2 of { happy_var_2 -> - ( do { e <- checkExpr happy_var_2; - return $ HsSpliceExp $ HsParenSplice e })} - ) (\r -> happyReturn (happyIn110 r)) - -happyReduce_273 = happyMonadReduce 3# 106# happyReduction_273 -happyReduction_273 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut99 happy_x_2 of { happy_var_2 -> - ( do { e <- checkExpr happy_var_2; - return $ HsBracketExp $ HsExpBracket e })} - ) (\r -> happyReturn (happyIn110 r)) - -happyReduce_274 = happyMonadReduce 3# 106# happyReduction_274 -happyReduction_274 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut100 happy_x_2 of { happy_var_2 -> - ( do { p <- checkPattern happy_var_2; - return $ HsBracketExp $ HsPatBracket p })} - ) (\r -> happyReturn (happyIn110 r)) - -happyReduce_275 = happySpecReduce_3 106# happyReduction_275 -happyReduction_275 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut52 happy_x_2 of { happy_var_2 -> - happyIn110 - (HsBracketExp $ HsTypeBracket happy_var_2 - )} - -happyReduce_276 = happyReduce 5# 106# 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 happyOut31 happy_x_3 of { happy_var_3 -> - happyIn110 - (HsBracketExp $ HsDeclBracket happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_277 = happySpecReduce_2 106# happyReduction_277 -happyReduction_277 happy_x_2 - happy_x_1 - = case happyOut147 happy_x_2 of { happy_var_2 -> - happyIn110 - (HsVarQuote happy_var_2 - )} - -happyReduce_278 = happySpecReduce_2 106# happyReduction_278 -happyReduction_278 happy_x_2 - happy_x_1 - = case happyOut150 happy_x_2 of { happy_var_2 -> - happyIn110 - (HsVarQuote happy_var_2 - )} - -happyReduce_279 = happySpecReduce_2 106# happyReduction_279 -happyReduction_279 happy_x_2 - happy_x_1 - = case happyOut181 happy_x_2 of { happy_var_2 -> - happyIn110 - (HsTypQuote (UnQual happy_var_2) - )} - -happyReduce_280 = happySpecReduce_2 106# happyReduction_280 -happyReduction_280 happy_x_2 - happy_x_1 - = case happyOut50 happy_x_2 of { happy_var_2 -> - happyIn110 - (HsTypQuote happy_var_2 - )} - -happyReduce_281 = happySpecReduce_2 107# happyReduction_281 -happyReduction_281 happy_x_2 - happy_x_1 - = case happyOut111 happy_x_1 of { happy_var_1 -> - happyIn111 - (happy_var_1 + 1 - )} - -happyReduce_282 = happySpecReduce_1 107# happyReduction_282 -happyReduction_282 happy_x_1 - = happyIn111 - (1 - ) - -happyReduce_283 = happySpecReduce_3 108# happyReduction_283 -happyReduction_283 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut112 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - happyIn112 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_284 = happySpecReduce_3 108# happyReduction_284 -happyReduction_284 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - happyIn112 - ([happy_var_3,happy_var_1] - )}} - -happyReduce_285 = happySpecReduce_3 109# happyReduction_285 -happyReduction_285 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut113 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - happyIn113 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_286 = happySpecReduce_1 109# happyReduction_286 -happyReduction_286 happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - happyIn113 - ([happy_var_1] - )} - -happyReduce_287 = happySpecReduce_3 110# happyReduction_287 -happyReduction_287 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - case happyOut114 happy_x_3 of { happy_var_3 -> - happyIn114 - (HsEitherRP happy_var_1 happy_var_3 - )}} - -happyReduce_288 = happySpecReduce_3 110# happyReduction_288 -happyReduction_288 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - happyIn114 - (HsEitherRP happy_var_1 happy_var_3 - )}} - -happyReduce_289 = happyMonadReduce 10# 111# happyReduction_289 -happyReduction_289 (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 happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut118 happy_x_3 of { happy_var_3 -> - case happyOut120 happy_x_4 of { happy_var_4 -> - case happyOut122 happy_x_5 of { happy_var_5 -> - case happyOut116 happy_x_7 of { happy_var_7 -> - case happyOut118 happy_x_9 of { happy_var_9 -> - ( do { n <- checkEqNames happy_var_3 happy_var_9; - let { cn = reverse happy_var_7; - as = reverse happy_var_4; }; - return $ HsXTag happy_var_1 n as happy_var_5 cn })}}}}}} - ) (\r -> happyReturn (happyIn115 r)) - -happyReduce_290 = happyReduce 6# 111# happyReduction_290 -happyReduction_290 (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 happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut118 happy_x_3 of { happy_var_3 -> - case happyOut120 happy_x_4 of { happy_var_4 -> - case happyOut122 happy_x_5 of { happy_var_5 -> - happyIn115 - (HsXETag happy_var_1 happy_var_3 (reverse happy_var_4) happy_var_5 - ) `HappyStk` happyRest}}}} - -happyReduce_291 = happySpecReduce_3 111# happyReduction_291 -happyReduction_291 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut99 happy_x_2 of { happy_var_2 -> - happyIn115 - (HsXExpTag happy_var_2 - )} - -happyReduce_292 = happySpecReduce_2 112# happyReduction_292 -happyReduction_292 happy_x_2 - happy_x_1 - = case happyOut116 happy_x_1 of { happy_var_1 -> - case happyOut117 happy_x_2 of { happy_var_2 -> - happyIn116 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_293 = happySpecReduce_0 112# happyReduction_293 -happyReduction_293 = happyIn116 - ([] - ) - -happyReduce_294 = happySpecReduce_1 113# happyReduction_294 -happyReduction_294 happy_x_1 - = case happyOutTok happy_x_1 of { (XPcdata happy_var_1) -> - happyIn117 - (HsXPcdata happy_var_1 - )} - -happyReduce_295 = happySpecReduce_3 113# happyReduction_295 -happyReduction_295 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut113 happy_x_2 of { happy_var_2 -> - happyIn117 - (HsXRPats $ reverse happy_var_2 - )} - -happyReduce_296 = happySpecReduce_1 113# happyReduction_296 -happyReduction_296 happy_x_1 - = case happyOut115 happy_x_1 of { happy_var_1 -> - happyIn117 - (happy_var_1 - )} - -happyReduce_297 = happySpecReduce_3 114# happyReduction_297 -happyReduction_297 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut119 happy_x_1 of { happy_var_1 -> - case happyOut119 happy_x_3 of { happy_var_3 -> - happyIn118 - (HsXDomName happy_var_1 happy_var_3 - )}} - -happyReduce_298 = happySpecReduce_1 114# happyReduction_298 -happyReduction_298 happy_x_1 - = case happyOut119 happy_x_1 of { happy_var_1 -> - happyIn118 - (HsXName happy_var_1 - )} - -happyReduce_299 = happySpecReduce_1 115# happyReduction_299 -happyReduction_299 happy_x_1 - = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> - happyIn119 - (happy_var_1 - )} - -happyReduce_300 = happySpecReduce_1 115# happyReduction_300 -happyReduction_300 happy_x_1 - = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> - happyIn119 - (happy_var_1 - )} - -happyReduce_301 = happySpecReduce_1 115# happyReduction_301 -happyReduction_301 happy_x_1 - = case happyOutTok happy_x_1 of { (DVarId happy_var_1) -> - happyIn119 - (mkDVar happy_var_1 - )} - -happyReduce_302 = happySpecReduce_1 115# happyReduction_302 -happyReduction_302 happy_x_1 - = happyIn119 - ("type" - ) - -happyReduce_303 = happySpecReduce_1 115# happyReduction_303 -happyReduction_303 happy_x_1 - = happyIn119 - ("class" - ) - -happyReduce_304 = happySpecReduce_2 116# happyReduction_304 -happyReduction_304 happy_x_2 - happy_x_1 - = case happyOut120 happy_x_1 of { happy_var_1 -> - case happyOut121 happy_x_2 of { happy_var_2 -> - happyIn120 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_305 = happySpecReduce_0 116# happyReduction_305 -happyReduction_305 = happyIn120 - ([] - ) - -happyReduce_306 = happySpecReduce_3 117# happyReduction_306 -happyReduction_306 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut118 happy_x_1 of { happy_var_1 -> - case happyOut108 happy_x_3 of { happy_var_3 -> - happyIn121 - (HsXAttr happy_var_1 happy_var_3 - )}} - -happyReduce_307 = happySpecReduce_1 118# happyReduction_307 -happyReduction_307 happy_x_1 - = case happyOut108 happy_x_1 of { happy_var_1 -> - happyIn122 - (Just happy_var_1 - )} - -happyReduce_308 = happySpecReduce_0 118# happyReduction_308 -happyReduction_308 = happyIn122 - (Nothing - ) - -happyReduce_309 = happySpecReduce_1 119# happyReduction_309 -happyReduction_309 happy_x_1 - = case happyOutTok happy_x_1 of { (DVarId happy_var_1) -> - happyIn123 - (mkDVarExpr happy_var_1 - )} - -happyReduce_310 = happySpecReduce_1 120# happyReduction_310 -happyReduction_310 happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - happyIn124 - (HsList [happy_var_1] - )} - -happyReduce_311 = happySpecReduce_1 120# happyReduction_311 -happyReduction_311 happy_x_1 - = case happyOut125 happy_x_1 of { happy_var_1 -> - happyIn124 - (HsList (reverse happy_var_1) - )} - -happyReduce_312 = happySpecReduce_2 120# happyReduction_312 -happyReduction_312 happy_x_2 - happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - happyIn124 - (HsEnumFrom happy_var_1 - )} - -happyReduce_313 = happyReduce 4# 120# happyReduction_313 -happyReduction_313 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut99 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - happyIn124 - (HsEnumFromThen happy_var_1 happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_314 = happySpecReduce_3 120# happyReduction_314 -happyReduction_314 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - happyIn124 - (HsEnumFromTo happy_var_1 happy_var_3 - )}} - -happyReduce_315 = happyReduce 5# 120# happyReduction_315 -happyReduction_315 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut99 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - case happyOut99 happy_x_5 of { happy_var_5 -> - happyIn124 - (HsEnumFromThenTo happy_var_1 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_316 = happySpecReduce_3 120# happyReduction_316 -happyReduction_316 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - case happyOut126 happy_x_3 of { happy_var_3 -> - happyIn124 - (HsListComp happy_var_1 (reverse happy_var_3) - )}} - -happyReduce_317 = happySpecReduce_3 121# happyReduction_317 -happyReduction_317 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut125 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - happyIn125 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_318 = happySpecReduce_3 121# happyReduction_318 -happyReduction_318 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - happyIn125 - ([happy_var_3,happy_var_1] - )}} - -happyReduce_319 = happyMonadReduce 1# 122# happyReduction_319 -happyReduction_319 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> - ( mapM checkStmt happy_var_1)} - ) (\r -> happyReturn (happyIn126 r)) - -happyReduce_320 = happySpecReduce_3 123# happyReduction_320 -happyReduction_320 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut127 happy_x_1 of { happy_var_1 -> - case happyOut128 happy_x_3 of { happy_var_3 -> - happyIn127 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_321 = happySpecReduce_1 123# happyReduction_321 -happyReduction_321 happy_x_1 - = case happyOut128 happy_x_1 of { happy_var_1 -> - happyIn127 - ([happy_var_1] - )} - -happyReduce_322 = happyReduce 4# 124# happyReduction_322 -happyReduction_322 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut136 happy_x_1 of { happy_var_1 -> - case happyOut174 happy_x_2 of { happy_var_2 -> - case happyOut99 happy_x_4 of { happy_var_4 -> - happyIn128 - (HsGenerator happy_var_2 happy_var_1 happy_var_4 - ) `HappyStk` happyRest}}} - -happyReduce_323 = happySpecReduce_1 124# happyReduction_323 -happyReduction_323 happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - happyIn128 - (HsQualifier happy_var_1 - )} - -happyReduce_324 = happySpecReduce_2 124# happyReduction_324 -happyReduction_324 happy_x_2 - happy_x_1 - = case happyOut41 happy_x_2 of { happy_var_2 -> - happyIn128 - (HsLetStmt happy_var_2 - )} - -happyReduce_325 = happySpecReduce_3 125# happyReduction_325 -happyReduction_325 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut130 happy_x_2 of { happy_var_2 -> - happyIn129 - (happy_var_2 - )} - -happyReduce_326 = happySpecReduce_3 125# happyReduction_326 -happyReduction_326 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut130 happy_x_2 of { happy_var_2 -> - happyIn129 - (happy_var_2 - )} - -happyReduce_327 = happySpecReduce_3 126# happyReduction_327 -happyReduction_327 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut131 happy_x_2 of { happy_var_2 -> - happyIn130 - (reverse happy_var_2 - )} - -happyReduce_328 = happySpecReduce_3 127# happyReduction_328 -happyReduction_328 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut131 happy_x_1 of { happy_var_1 -> - case happyOut132 happy_x_3 of { happy_var_3 -> - happyIn131 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_329 = happySpecReduce_1 127# happyReduction_329 -happyReduction_329 happy_x_1 - = case happyOut132 happy_x_1 of { happy_var_1 -> - happyIn131 - ([happy_var_1] - )} - -happyReduce_330 = happyReduce 4# 128# happyReduction_330 -happyReduction_330 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut136 happy_x_2 of { happy_var_2 -> - case happyOut133 happy_x_3 of { happy_var_3 -> - case happyOut95 happy_x_4 of { happy_var_4 -> - happyIn132 - (HsAlt happy_var_1 happy_var_2 happy_var_3 happy_var_4 - ) `HappyStk` happyRest}}}} - -happyReduce_331 = happySpecReduce_2 129# happyReduction_331 -happyReduction_331 happy_x_2 - happy_x_1 - = case happyOut99 happy_x_2 of { happy_var_2 -> - happyIn133 - (HsUnGuardedAlt happy_var_2 - )} - -happyReduce_332 = happySpecReduce_1 129# happyReduction_332 -happyReduction_332 happy_x_1 - = case happyOut134 happy_x_1 of { happy_var_1 -> - happyIn133 - (HsGuardedAlts (reverse happy_var_1) - )} - -happyReduce_333 = happySpecReduce_2 130# happyReduction_333 -happyReduction_333 happy_x_2 - happy_x_1 - = case happyOut134 happy_x_1 of { happy_var_1 -> - case happyOut135 happy_x_2 of { happy_var_2 -> - happyIn134 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_334 = happySpecReduce_1 130# happyReduction_334 -happyReduction_334 happy_x_1 - = case happyOut135 happy_x_1 of { happy_var_1 -> - happyIn134 - ([happy_var_1] - )} - -happyReduce_335 = happyReduce 5# 131# happyReduction_335 -happyReduction_335 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut126 happy_x_3 of { happy_var_3 -> - case happyOut99 happy_x_5 of { happy_var_5 -> - happyIn135 - (HsGuardedAlt happy_var_1 (reverse happy_var_3) happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_336 = happyMonadReduce 1# 132# happyReduction_336 -happyReduction_336 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut102 happy_x_1 of { happy_var_1 -> - ( checkPattern happy_var_1)} - ) (\r -> happyReturn (happyIn136 r)) - -happyReduce_337 = happySpecReduce_3 133# happyReduction_337 -happyReduction_337 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut138 happy_x_2 of { happy_var_2 -> - happyIn137 - (happy_var_2 - )} - -happyReduce_338 = happySpecReduce_3 133# happyReduction_338 -happyReduction_338 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut138 happy_x_2 of { happy_var_2 -> - happyIn137 - (happy_var_2 - )} - -happyReduce_339 = happyReduce 4# 134# happyReduction_339 -happyReduction_339 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut41 happy_x_2 of { happy_var_2 -> - case happyOut138 happy_x_4 of { happy_var_4 -> - happyIn138 - (HsLetStmt happy_var_2 : happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_340 = happyReduce 6# 134# happyReduction_340 -happyReduction_340 (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 happyOut136 happy_x_1 of { happy_var_1 -> - case happyOut174 happy_x_2 of { happy_var_2 -> - case happyOut99 happy_x_4 of { happy_var_4 -> - case happyOut138 happy_x_6 of { happy_var_6 -> - happyIn138 - (HsGenerator happy_var_2 happy_var_1 happy_var_4 : happy_var_6 - ) `HappyStk` happyRest}}}} - -happyReduce_341 = happySpecReduce_3 134# happyReduction_341 -happyReduction_341 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - case happyOut138 happy_x_3 of { happy_var_3 -> - happyIn138 - (HsQualifier happy_var_1 : happy_var_3 - )}} - -happyReduce_342 = happySpecReduce_2 134# happyReduction_342 -happyReduction_342 happy_x_2 - happy_x_1 - = case happyOut138 happy_x_2 of { happy_var_2 -> - happyIn138 - (happy_var_2 - )} - -happyReduce_343 = happySpecReduce_2 134# happyReduction_343 -happyReduction_343 happy_x_2 - happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - happyIn138 - ([HsQualifier happy_var_1] - )} - -happyReduce_344 = happySpecReduce_1 134# happyReduction_344 -happyReduction_344 happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - happyIn138 - ([HsQualifier happy_var_1] - )} - -happyReduce_345 = happySpecReduce_3 135# happyReduction_345 -happyReduction_345 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut139 happy_x_1 of { happy_var_1 -> - case happyOut140 happy_x_3 of { happy_var_3 -> - happyIn139 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_346 = happySpecReduce_1 135# happyReduction_346 -happyReduction_346 happy_x_1 - = case happyOut140 happy_x_1 of { happy_var_1 -> - happyIn139 - ([happy_var_1] - )} - -happyReduce_347 = happySpecReduce_3 136# happyReduction_347 -happyReduction_347 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut147 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - happyIn140 - (HsFieldUpdate happy_var_1 happy_var_3 - )}} - -happyReduce_348 = happySpecReduce_3 137# happyReduction_348 -happyReduction_348 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut142 happy_x_2 of { happy_var_2 -> - happyIn141 - (reverse happy_var_2 - )} - -happyReduce_349 = happySpecReduce_3 138# happyReduction_349 -happyReduction_349 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut142 happy_x_1 of { happy_var_1 -> - case happyOut143 happy_x_3 of { happy_var_3 -> - happyIn142 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_350 = happySpecReduce_1 138# happyReduction_350 -happyReduction_350 happy_x_1 - = case happyOut143 happy_x_1 of { happy_var_1 -> - happyIn142 - ([happy_var_1] - )} - -happyReduce_351 = happyReduce 4# 139# happyReduction_351 -happyReduction_351 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut148 happy_x_2 of { happy_var_2 -> - case happyOut99 happy_x_4 of { happy_var_4 -> - happyIn143 - (HsIPBind happy_var_1 happy_var_2 happy_var_4 - ) `HappyStk` happyRest}}} - -happyReduce_352 = happySpecReduce_2 140# happyReduction_352 -happyReduction_352 happy_x_2 - happy_x_1 - = happyIn144 - (unit_con - ) - -happyReduce_353 = happySpecReduce_2 140# happyReduction_353 -happyReduction_353 happy_x_2 - happy_x_1 - = happyIn144 - (HsList [] - ) - -happyReduce_354 = happySpecReduce_3 140# happyReduction_354 -happyReduction_354 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut111 happy_x_2 of { happy_var_2 -> - happyIn144 - (tuple_con happy_var_2 - )} - -happyReduce_355 = happySpecReduce_1 140# happyReduction_355 -happyReduction_355 happy_x_1 - = case happyOut150 happy_x_1 of { happy_var_1 -> - happyIn144 - (HsCon happy_var_1 - )} - -happyReduce_356 = happySpecReduce_1 141# happyReduction_356 -happyReduction_356 happy_x_1 - = case happyOut162 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_357 = happySpecReduce_3 141# happyReduction_357 -happyReduction_357 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut170 happy_x_2 of { happy_var_2 -> - happyIn145 - (happy_var_2 - )} - -happyReduce_358 = happySpecReduce_1 142# happyReduction_358 -happyReduction_358 happy_x_1 - = case happyOut161 happy_x_1 of { happy_var_1 -> - happyIn146 - (happy_var_1 - )} - -happyReduce_359 = happySpecReduce_3 142# happyReduction_359 -happyReduction_359 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut170 happy_x_2 of { happy_var_2 -> - happyIn146 - (happy_var_2 - )} - -happyReduce_360 = happySpecReduce_1 143# happyReduction_360 -happyReduction_360 happy_x_1 - = case happyOut160 happy_x_1 of { happy_var_1 -> - happyIn147 - (happy_var_1 - )} - -happyReduce_361 = happySpecReduce_3 143# happyReduction_361 -happyReduction_361 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut168 happy_x_2 of { happy_var_2 -> - happyIn147 - (happy_var_2 - )} - -happyReduce_362 = happySpecReduce_1 144# happyReduction_362 -happyReduction_362 happy_x_1 - = case happyOut163 happy_x_1 of { happy_var_1 -> - happyIn148 - (happy_var_1 - )} - -happyReduce_363 = happySpecReduce_1 145# happyReduction_363 -happyReduction_363 happy_x_1 - = case happyOut165 happy_x_1 of { happy_var_1 -> - happyIn149 - (happy_var_1 - )} - -happyReduce_364 = happySpecReduce_3 145# happyReduction_364 -happyReduction_364 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut167 happy_x_2 of { happy_var_2 -> - happyIn149 - (happy_var_2 - )} - -happyReduce_365 = happySpecReduce_1 146# happyReduction_365 -happyReduction_365 happy_x_1 - = case happyOut164 happy_x_1 of { happy_var_1 -> - happyIn150 - (happy_var_1 - )} - -happyReduce_366 = happySpecReduce_3 146# happyReduction_366 -happyReduction_366 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut159 happy_x_2 of { happy_var_2 -> - happyIn150 - (happy_var_2 - )} - -happyReduce_367 = happySpecReduce_1 147# happyReduction_367 -happyReduction_367 happy_x_1 - = case happyOut170 happy_x_1 of { happy_var_1 -> - happyIn151 - (happy_var_1 - )} - -happyReduce_368 = happySpecReduce_3 147# happyReduction_368 -happyReduction_368 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut162 happy_x_2 of { happy_var_2 -> - happyIn151 - (happy_var_2 - )} - -happyReduce_369 = happySpecReduce_1 148# happyReduction_369 -happyReduction_369 happy_x_1 - = case happyOut168 happy_x_1 of { happy_var_1 -> - happyIn152 - (happy_var_1 - )} - -happyReduce_370 = happySpecReduce_3 148# happyReduction_370 -happyReduction_370 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut160 happy_x_2 of { happy_var_2 -> - happyIn152 - (happy_var_2 - )} - -happyReduce_371 = happySpecReduce_1 149# happyReduction_371 -happyReduction_371 happy_x_1 - = case happyOut169 happy_x_1 of { happy_var_1 -> - happyIn153 - (happy_var_1 - )} - -happyReduce_372 = happySpecReduce_3 149# happyReduction_372 -happyReduction_372 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut160 happy_x_2 of { happy_var_2 -> - happyIn153 - (happy_var_2 - )} - -happyReduce_373 = happySpecReduce_1 150# happyReduction_373 -happyReduction_373 happy_x_1 - = case happyOut167 happy_x_1 of { happy_var_1 -> - happyIn154 - (happy_var_1 - )} - -happyReduce_374 = happySpecReduce_3 150# happyReduction_374 -happyReduction_374 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut165 happy_x_2 of { happy_var_2 -> - happyIn154 - (happy_var_2 - )} - -happyReduce_375 = happySpecReduce_1 151# happyReduction_375 -happyReduction_375 happy_x_1 - = case happyOut159 happy_x_1 of { happy_var_1 -> - happyIn155 - (happy_var_1 - )} - -happyReduce_376 = happySpecReduce_3 151# happyReduction_376 -happyReduction_376 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut164 happy_x_2 of { happy_var_2 -> - happyIn155 - (happy_var_2 - )} - -happyReduce_377 = happySpecReduce_1 152# happyReduction_377 -happyReduction_377 happy_x_1 - = case happyOut151 happy_x_1 of { happy_var_1 -> - happyIn156 - (HsVarOp happy_var_1 - )} - -happyReduce_378 = happySpecReduce_1 152# happyReduction_378 -happyReduction_378 happy_x_1 - = case happyOut154 happy_x_1 of { happy_var_1 -> - happyIn156 - (HsConOp happy_var_1 - )} - -happyReduce_379 = happySpecReduce_1 153# happyReduction_379 -happyReduction_379 happy_x_1 - = case happyOut152 happy_x_1 of { happy_var_1 -> - happyIn157 - (HsQVarOp happy_var_1 - )} - -happyReduce_380 = happySpecReduce_1 153# happyReduction_380 -happyReduction_380 happy_x_1 - = case happyOut155 happy_x_1 of { happy_var_1 -> - happyIn157 - (HsQConOp happy_var_1 - )} - -happyReduce_381 = happySpecReduce_1 154# happyReduction_381 -happyReduction_381 happy_x_1 - = case happyOut153 happy_x_1 of { happy_var_1 -> - happyIn158 - (HsQVarOp happy_var_1 - )} - -happyReduce_382 = happySpecReduce_1 154# happyReduction_382 -happyReduction_382 happy_x_1 - = case happyOut155 happy_x_1 of { happy_var_1 -> - happyIn158 - (HsQConOp happy_var_1 - )} - -happyReduce_383 = happySpecReduce_1 155# happyReduction_383 -happyReduction_383 happy_x_1 - = happyIn159 - (list_cons_name - ) - -happyReduce_384 = happySpecReduce_1 155# happyReduction_384 -happyReduction_384 happy_x_1 - = case happyOut166 happy_x_1 of { happy_var_1 -> - happyIn159 - (happy_var_1 - )} - -happyReduce_385 = happySpecReduce_1 156# happyReduction_385 -happyReduction_385 happy_x_1 - = case happyOut162 happy_x_1 of { happy_var_1 -> - happyIn160 - (UnQual happy_var_1 - )} - -happyReduce_386 = happySpecReduce_1 156# happyReduction_386 -happyReduction_386 happy_x_1 - = case happyOutTok happy_x_1 of { (QVarId happy_var_1) -> - happyIn160 - (Qual (Module (fst happy_var_1)) (HsIdent (snd happy_var_1)) - )} - -happyReduce_387 = happySpecReduce_1 157# happyReduction_387 -happyReduction_387 happy_x_1 - = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> - happyIn161 - (HsIdent happy_var_1 - )} - -happyReduce_388 = happySpecReduce_1 157# happyReduction_388 -happyReduction_388 happy_x_1 - = happyIn161 - (as_name - ) - -happyReduce_389 = happySpecReduce_1 157# happyReduction_389 -happyReduction_389 happy_x_1 - = happyIn161 - (qualified_name - ) - -happyReduce_390 = happySpecReduce_1 157# happyReduction_390 -happyReduction_390 happy_x_1 - = happyIn161 - (hiding_name - ) - -happyReduce_391 = happySpecReduce_1 157# happyReduction_391 -happyReduction_391 happy_x_1 - = happyIn161 - (export_name - ) - -happyReduce_392 = happySpecReduce_1 157# happyReduction_392 -happyReduction_392 happy_x_1 - = happyIn161 - (stdcall_name - ) - -happyReduce_393 = happySpecReduce_1 157# happyReduction_393 -happyReduction_393 happy_x_1 - = happyIn161 - (ccall_name - ) - -happyReduce_394 = happySpecReduce_1 158# happyReduction_394 -happyReduction_394 happy_x_1 - = case happyOut161 happy_x_1 of { happy_var_1 -> - happyIn162 - (happy_var_1 - )} - -happyReduce_395 = happySpecReduce_1 158# happyReduction_395 -happyReduction_395 happy_x_1 - = happyIn162 - (safe_name - ) - -happyReduce_396 = happySpecReduce_1 158# happyReduction_396 -happyReduction_396 happy_x_1 - = happyIn162 - (unsafe_name - ) - -happyReduce_397 = happySpecReduce_1 158# happyReduction_397 -happyReduction_397 happy_x_1 - = happyIn162 - (threadsafe_name - ) - -happyReduce_398 = happySpecReduce_1 159# happyReduction_398 -happyReduction_398 happy_x_1 - = case happyOutTok happy_x_1 of { (IDupVarId happy_var_1) -> - happyIn163 - (HsIPDup happy_var_1 - )} - -happyReduce_399 = happySpecReduce_1 159# happyReduction_399 -happyReduction_399 happy_x_1 - = case happyOutTok happy_x_1 of { (ILinVarId happy_var_1) -> - happyIn163 - (HsIPLin happy_var_1 - )} - -happyReduce_400 = happySpecReduce_1 160# happyReduction_400 -happyReduction_400 happy_x_1 - = case happyOut165 happy_x_1 of { happy_var_1 -> - happyIn164 - (UnQual happy_var_1 - )} - -happyReduce_401 = happySpecReduce_1 160# happyReduction_401 -happyReduction_401 happy_x_1 - = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> - happyIn164 - (Qual (Module (fst happy_var_1)) (HsIdent (snd happy_var_1)) - )} - -happyReduce_402 = happySpecReduce_1 161# happyReduction_402 -happyReduction_402 happy_x_1 - = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> - happyIn165 - (HsIdent happy_var_1 - )} - -happyReduce_403 = happySpecReduce_1 162# happyReduction_403 -happyReduction_403 happy_x_1 - = case happyOut167 happy_x_1 of { happy_var_1 -> - happyIn166 - (UnQual happy_var_1 - )} - -happyReduce_404 = happySpecReduce_1 162# happyReduction_404 -happyReduction_404 happy_x_1 - = case happyOutTok happy_x_1 of { (QConSym happy_var_1) -> - happyIn166 - (Qual (Module (fst happy_var_1)) (HsSymbol (snd happy_var_1)) - )} - -happyReduce_405 = happySpecReduce_1 163# happyReduction_405 -happyReduction_405 happy_x_1 - = case happyOutTok happy_x_1 of { (ConSym happy_var_1) -> - happyIn167 - (HsSymbol happy_var_1 - )} - -happyReduce_406 = happySpecReduce_1 164# happyReduction_406 -happyReduction_406 happy_x_1 - = case happyOut170 happy_x_1 of { happy_var_1 -> - happyIn168 - (UnQual happy_var_1 - )} - -happyReduce_407 = happySpecReduce_1 164# happyReduction_407 -happyReduction_407 happy_x_1 - = case happyOut172 happy_x_1 of { happy_var_1 -> - happyIn168 - (happy_var_1 - )} - -happyReduce_408 = happySpecReduce_1 165# happyReduction_408 -happyReduction_408 happy_x_1 - = case happyOut171 happy_x_1 of { happy_var_1 -> - happyIn169 - (UnQual happy_var_1 - )} - -happyReduce_409 = happySpecReduce_1 165# happyReduction_409 -happyReduction_409 happy_x_1 - = case happyOut172 happy_x_1 of { happy_var_1 -> - happyIn169 - (happy_var_1 - )} - -happyReduce_410 = happySpecReduce_1 166# happyReduction_410 -happyReduction_410 happy_x_1 - = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> - happyIn170 - (HsSymbol happy_var_1 - )} - -happyReduce_411 = happySpecReduce_1 166# happyReduction_411 -happyReduction_411 happy_x_1 - = happyIn170 - (minus_name - ) - -happyReduce_412 = happySpecReduce_1 166# happyReduction_412 -happyReduction_412 happy_x_1 - = happyIn170 - (pling_name - ) - -happyReduce_413 = happySpecReduce_1 166# happyReduction_413 -happyReduction_413 happy_x_1 - = happyIn170 - (dot_name - ) - -happyReduce_414 = happySpecReduce_1 166# happyReduction_414 -happyReduction_414 happy_x_1 - = happyIn170 - (star_name - ) - -happyReduce_415 = happySpecReduce_1 167# happyReduction_415 -happyReduction_415 happy_x_1 - = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> - happyIn171 - (HsSymbol happy_var_1 - )} - -happyReduce_416 = happySpecReduce_1 167# happyReduction_416 -happyReduction_416 happy_x_1 - = happyIn171 - (pling_name - ) - -happyReduce_417 = happySpecReduce_1 167# happyReduction_417 -happyReduction_417 happy_x_1 - = happyIn171 - (dot_name - ) - -happyReduce_418 = happySpecReduce_1 167# happyReduction_418 -happyReduction_418 happy_x_1 - = happyIn171 - (star_name - ) - -happyReduce_419 = happySpecReduce_1 168# happyReduction_419 -happyReduction_419 happy_x_1 - = case happyOutTok happy_x_1 of { (QVarSym happy_var_1) -> - happyIn172 - (Qual (Module (fst happy_var_1)) (HsSymbol (snd happy_var_1)) - )} - -happyReduce_420 = happySpecReduce_1 169# happyReduction_420 -happyReduction_420 happy_x_1 - = case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> - happyIn173 - (HsInt happy_var_1 - )} - -happyReduce_421 = happySpecReduce_1 169# happyReduction_421 -happyReduction_421 happy_x_1 - = case happyOutTok happy_x_1 of { (Character happy_var_1) -> - happyIn173 - (HsChar happy_var_1 - )} - -happyReduce_422 = happySpecReduce_1 169# happyReduction_422 -happyReduction_422 happy_x_1 - = case happyOutTok happy_x_1 of { (FloatTok happy_var_1) -> - happyIn173 - (HsFrac happy_var_1 - )} - -happyReduce_423 = happySpecReduce_1 169# happyReduction_423 -happyReduction_423 happy_x_1 - = case happyOutTok happy_x_1 of { (StringTok happy_var_1) -> - happyIn173 - (HsString happy_var_1 - )} - -happyReduce_424 = happyMonadReduce 0# 170# happyReduction_424 -happyReduction_424 (happyRest) tk - = happyThen (( getSrcLoc) - ) (\r -> happyReturn (happyIn174 r)) - -happyReduce_425 = happyMonadReduce 0# 171# happyReduction_425 -happyReduction_425 (happyRest) tk - = happyThen (( pushCurrentContext) - ) (\r -> happyReturn (happyIn175 r)) - -happyReduce_426 = happySpecReduce_1 172# happyReduction_426 -happyReduction_426 happy_x_1 - = happyIn176 - (() - ) - -happyReduce_427 = happyMonadReduce 1# 172# happyReduction_427 -happyReduction_427 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (( popContext) - ) (\r -> happyReturn (happyIn176 r)) - -happyReduce_428 = happySpecReduce_1 173# happyReduction_428 -happyReduction_428 happy_x_1 - = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> - happyIn177 - (Module happy_var_1 - )} - -happyReduce_429 = happySpecReduce_1 173# happyReduction_429 -happyReduction_429 happy_x_1 - = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> - happyIn177 - (Module (fst happy_var_1 ++ '.':snd happy_var_1) - )} - -happyReduce_430 = happySpecReduce_1 174# happyReduction_430 -happyReduction_430 happy_x_1 - = case happyOut165 happy_x_1 of { happy_var_1 -> - happyIn178 - (happy_var_1 - )} - -happyReduce_431 = happySpecReduce_1 175# happyReduction_431 -happyReduction_431 happy_x_1 - = case happyOut164 happy_x_1 of { happy_var_1 -> - happyIn179 - (happy_var_1 - )} - -happyReduce_432 = happySpecReduce_1 176# happyReduction_432 -happyReduction_432 happy_x_1 - = case happyOut164 happy_x_1 of { happy_var_1 -> - happyIn180 - (happy_var_1 - )} - -happyReduce_433 = happySpecReduce_1 177# happyReduction_433 -happyReduction_433 happy_x_1 - = case happyOut162 happy_x_1 of { happy_var_1 -> - happyIn181 - (happy_var_1 - )} - -happyReduce_434 = happySpecReduce_3 178# happyReduction_434 -happyReduction_434 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut181 happy_x_2 of { happy_var_2 -> - happyIn182 - (UnQual happy_var_2 - )} - -happyReduce_435 = happySpecReduce_1 178# happyReduction_435 -happyReduction_435 happy_x_1 - = case happyOut183 happy_x_1 of { happy_var_1 -> - happyIn182 - (UnQual happy_var_1 - )} - -happyReduce_436 = happySpecReduce_1 179# happyReduction_436 -happyReduction_436 happy_x_1 - = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> - happyIn183 - (HsSymbol happy_var_1 - )} - -happyNewToken action sts stk - = lexer(\tk -> - let cont i = happyDoAction i tk action sts stk in - case tk of { - EOF -> happyDoAction 99# tk action sts stk; - VarId happy_dollar_dollar -> cont 1#; - QVarId happy_dollar_dollar -> cont 2#; - IDupVarId happy_dollar_dollar -> cont 3#; - ILinVarId happy_dollar_dollar -> cont 4#; - ConId happy_dollar_dollar -> cont 5#; - QConId happy_dollar_dollar -> cont 6#; - DVarId happy_dollar_dollar -> cont 7#; - VarSym happy_dollar_dollar -> cont 8#; - ConSym happy_dollar_dollar -> cont 9#; - QVarSym happy_dollar_dollar -> cont 10#; - QConSym happy_dollar_dollar -> cont 11#; - IntTok happy_dollar_dollar -> cont 12#; - FloatTok happy_dollar_dollar -> cont 13#; - Character happy_dollar_dollar -> cont 14#; - StringTok happy_dollar_dollar -> cont 15#; - LeftParen -> cont 16#; - RightParen -> cont 17#; - LeftHashParen -> cont 18#; - RightHashParen -> cont 19#; - SemiColon -> cont 20#; - LeftCurly -> cont 21#; - RightCurly -> cont 22#; - VRightCurly -> cont 23#; - LeftSquare -> cont 24#; - RightSquare -> cont 25#; - Comma -> cont 26#; - Underscore -> cont 27#; - BackQuote -> cont 28#; - Dot -> cont 29#; - DotDot -> cont 30#; - Colon -> cont 31#; - DoubleColon -> cont 32#; - Equals -> cont 33#; - Backslash -> cont 34#; - Bar -> cont 35#; - LeftArrow -> cont 36#; - RightArrow -> cont 37#; - At -> cont 38#; - Tilde -> cont 39#; - DoubleArrow -> cont 40#; - Minus -> cont 41#; - Exclamation -> cont 42#; - Star -> cont 43#; - RPGuardOpen -> cont 44#; - RPGuardClose -> cont 45#; - RPCAt -> cont 46#; - THIdEscape happy_dollar_dollar -> cont 47#; - THParenEscape -> cont 48#; - THExpQuote -> cont 49#; - THPatQuote -> cont 50#; - THTypQuote -> cont 51#; - THDecQuote -> cont 52#; - THCloseQuote -> cont 53#; - THVarQuote -> cont 54#; - THTyQuote -> cont 55#; - XPcdata happy_dollar_dollar -> cont 56#; - XStdTagOpen -> cont 57#; - XCloseTagOpen -> cont 58#; - XCodeTagOpen -> cont 59#; - XStdTagClose -> cont 60#; - XEmptyTagClose -> cont 61#; - XCodeTagClose -> cont 62#; - XRPatOpen -> cont 63#; - XRPatClose -> cont 64#; - KW_Foreign -> cont 65#; - KW_Export -> cont 66#; - KW_Safe -> cont 67#; - KW_Unsafe -> cont 68#; - KW_Threadsafe -> cont 69#; - KW_StdCall -> cont 70#; - KW_CCall -> cont 71#; - KW_As -> cont 72#; - KW_Case -> cont 73#; - KW_Class -> cont 74#; - KW_Data -> cont 75#; - KW_Default -> cont 76#; - KW_Deriving -> cont 77#; - KW_Do -> cont 78#; - KW_Else -> cont 79#; - KW_Family -> cont 80#; - KW_Forall -> cont 81#; - KW_Hiding -> cont 82#; - KW_If -> cont 83#; - KW_Import -> cont 84#; - KW_In -> cont 85#; - KW_Infix -> cont 86#; - KW_InfixL -> cont 87#; - KW_InfixR -> cont 88#; - KW_Instance -> cont 89#; - KW_Let -> cont 90#; - KW_MDo -> cont 91#; - KW_Module -> cont 92#; - KW_NewType -> cont 93#; - KW_Of -> cont 94#; - KW_Then -> cont 95#; - KW_Type -> cont 96#; - KW_Where -> cont 97#; - KW_Qualified -> cont 98#; - _ -> happyError' tk - }) - -happyError_ tk = happyError' tk - -happyThen :: () => P a -> (a -> P b) -> P b -happyThen = (>>=) -happyReturn :: () => a -> P a -happyReturn = (return) -happyThen1 = happyThen -happyReturn1 :: () => a -> P a -happyReturn1 = happyReturn -happyError' :: () => Token -> P a -happyError' tk = (\token -> happyError) tk - -parse = happySomeParser where - happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut4 x)) - -happySeq = happyDontSeq - - -happyError :: P a -happyError = fail "Parse error" - --- | Parse of a string, which should contain a complete Haskell 98 module. -parseModule :: String -> ParseResult HsModule -parseModule = runParser parse - --- | Parse of a string, which should contain a complete Haskell 98 module. -parseModuleWithMode :: ParseMode -> String -> ParseResult HsModule +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 :: (Module) -> (HappyAbsSyn ) +happyIn6 x = unsafeCoerce# x +{-# INLINE happyIn6 #-} +happyOut6 :: (HappyAbsSyn ) -> (Module) +happyOut6 x = unsafeCoerce# x +{-# INLINE happyOut6 #-} +happyIn7 :: (([ImportDecl],[Decl])) -> (HappyAbsSyn ) +happyIn7 x = unsafeCoerce# x +{-# INLINE happyIn7 #-} +happyOut7 :: (HappyAbsSyn ) -> (([ImportDecl],[Decl])) +happyOut7 x = unsafeCoerce# x +{-# INLINE happyOut7 #-} +happyIn8 :: (([ImportDecl],[Decl])) -> (HappyAbsSyn ) +happyIn8 x = unsafeCoerce# x +{-# INLINE happyIn8 #-} +happyOut8 :: (HappyAbsSyn ) -> (([ImportDecl],[Decl])) +happyOut8 x = unsafeCoerce# x +{-# INLINE happyOut8 #-} +happyIn9 :: (()) -> (HappyAbsSyn ) +happyIn9 x = unsafeCoerce# x +{-# INLINE happyIn9 #-} +happyOut9 :: (HappyAbsSyn ) -> (()) +happyOut9 x = unsafeCoerce# x +{-# INLINE happyOut9 #-} +happyIn10 :: (()) -> (HappyAbsSyn ) +happyIn10 x = unsafeCoerce# x +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn ) -> (()) +happyOut10 x = unsafeCoerce# x +{-# INLINE happyOut10 #-} +happyIn11 :: (Maybe [ExportSpec]) -> (HappyAbsSyn ) +happyIn11 x = unsafeCoerce# x +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn ) -> (Maybe [ExportSpec]) +happyOut11 x = unsafeCoerce# x +{-# INLINE happyOut11 #-} +happyIn12 :: ([ExportSpec]) -> (HappyAbsSyn ) +happyIn12 x = unsafeCoerce# x +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn ) -> ([ExportSpec]) +happyOut12 x = unsafeCoerce# x +{-# INLINE happyOut12 #-} +happyIn13 :: (()) -> (HappyAbsSyn ) +happyIn13 x = unsafeCoerce# x +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn ) -> (()) +happyOut13 x = unsafeCoerce# x +{-# INLINE happyOut13 #-} +happyIn14 :: ([ExportSpec]) -> (HappyAbsSyn ) +happyIn14 x = unsafeCoerce# x +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn ) -> ([ExportSpec]) +happyOut14 x = unsafeCoerce# x +{-# INLINE happyOut14 #-} +happyIn15 :: (ExportSpec) -> (HappyAbsSyn ) +happyIn15 x = unsafeCoerce# x +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn ) -> (ExportSpec) +happyOut15 x = unsafeCoerce# x +{-# INLINE happyOut15 #-} +happyIn16 :: ([ImportDecl]) -> (HappyAbsSyn ) +happyIn16 x = unsafeCoerce# x +{-# INLINE happyIn16 #-} +happyOut16 :: (HappyAbsSyn ) -> ([ImportDecl]) +happyOut16 x = unsafeCoerce# x +{-# INLINE happyOut16 #-} +happyIn17 :: (ImportDecl) -> (HappyAbsSyn ) +happyIn17 x = unsafeCoerce# x +{-# INLINE happyIn17 #-} +happyOut17 :: (HappyAbsSyn ) -> (ImportDecl) +happyOut17 x = unsafeCoerce# x +{-# INLINE happyOut17 #-} +happyIn18 :: (Bool) -> (HappyAbsSyn ) +happyIn18 x = unsafeCoerce# x +{-# INLINE happyIn18 #-} +happyOut18 :: (HappyAbsSyn ) -> (Bool) +happyOut18 x = unsafeCoerce# x +{-# INLINE happyOut18 #-} +happyIn19 :: (Maybe ModuleName) -> (HappyAbsSyn ) +happyIn19 x = unsafeCoerce# x +{-# INLINE happyIn19 #-} +happyOut19 :: (HappyAbsSyn ) -> (Maybe ModuleName) +happyOut19 x = unsafeCoerce# x +{-# INLINE happyOut19 #-} +happyIn20 :: (Maybe (Bool, [ImportSpec])) -> (HappyAbsSyn ) +happyIn20 x = unsafeCoerce# x +{-# INLINE happyIn20 #-} +happyOut20 :: (HappyAbsSyn ) -> (Maybe (Bool, [ImportSpec])) +happyOut20 x = unsafeCoerce# x +{-# INLINE happyOut20 #-} +happyIn21 :: ((Bool, [ImportSpec])) -> (HappyAbsSyn ) +happyIn21 x = unsafeCoerce# x +{-# INLINE happyIn21 #-} +happyOut21 :: (HappyAbsSyn ) -> ((Bool, [ImportSpec])) +happyOut21 x = unsafeCoerce# x +{-# INLINE happyOut21 #-} +happyIn22 :: (Bool) -> (HappyAbsSyn ) +happyIn22 x = unsafeCoerce# x +{-# INLINE happyIn22 #-} +happyOut22 :: (HappyAbsSyn ) -> (Bool) +happyOut22 x = unsafeCoerce# x +{-# INLINE happyOut22 #-} +happyIn23 :: ([ImportSpec]) -> (HappyAbsSyn ) +happyIn23 x = unsafeCoerce# x +{-# INLINE happyIn23 #-} +happyOut23 :: (HappyAbsSyn ) -> ([ImportSpec]) +happyOut23 x = unsafeCoerce# x +{-# INLINE happyOut23 #-} +happyIn24 :: (ImportSpec) -> (HappyAbsSyn ) +happyIn24 x = unsafeCoerce# x +{-# INLINE happyIn24 #-} +happyOut24 :: (HappyAbsSyn ) -> (ImportSpec) +happyOut24 x = unsafeCoerce# x +{-# INLINE happyOut24 #-} +happyIn25 :: ([CName]) -> (HappyAbsSyn ) +happyIn25 x = unsafeCoerce# x +{-# INLINE happyIn25 #-} +happyOut25 :: (HappyAbsSyn ) -> ([CName]) +happyOut25 x = unsafeCoerce# x +{-# INLINE happyOut25 #-} +happyIn26 :: (CName) -> (HappyAbsSyn ) +happyIn26 x = unsafeCoerce# x +{-# INLINE happyIn26 #-} +happyOut26 :: (HappyAbsSyn ) -> (CName) +happyOut26 x = unsafeCoerce# x +{-# INLINE happyOut26 #-} +happyIn27 :: (Decl) -> (HappyAbsSyn ) +happyIn27 x = unsafeCoerce# x +{-# INLINE happyIn27 #-} +happyOut27 :: (HappyAbsSyn ) -> (Decl) +happyOut27 x = unsafeCoerce# x +{-# INLINE happyOut27 #-} +happyIn28 :: (Int) -> (HappyAbsSyn ) +happyIn28 x = unsafeCoerce# x +{-# INLINE happyIn28 #-} +happyOut28 :: (HappyAbsSyn ) -> (Int) +happyOut28 x = unsafeCoerce# x +{-# INLINE happyOut28 #-} +happyIn29 :: (Assoc) -> (HappyAbsSyn ) +happyIn29 x = unsafeCoerce# x +{-# INLINE happyIn29 #-} +happyOut29 :: (HappyAbsSyn ) -> (Assoc) +happyOut29 x = unsafeCoerce# x +{-# INLINE happyOut29 #-} +happyIn30 :: ([Op]) -> (HappyAbsSyn ) +happyIn30 x = unsafeCoerce# x +{-# INLINE happyIn30 #-} +happyOut30 :: (HappyAbsSyn ) -> ([Op]) +happyOut30 x = unsafeCoerce# x +{-# INLINE happyOut30 #-} +happyIn31 :: ([Decl]) -> (HappyAbsSyn ) +happyIn31 x = unsafeCoerce# x +{-# INLINE happyIn31 #-} +happyOut31 :: (HappyAbsSyn ) -> ([Decl]) +happyOut31 x = unsafeCoerce# x +{-# INLINE happyOut31 #-} +happyIn32 :: ([Decl]) -> (HappyAbsSyn ) +happyIn32 x = unsafeCoerce# x +{-# INLINE happyIn32 #-} +happyOut32 :: (HappyAbsSyn ) -> ([Decl]) +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 :: (DataOrNew) -> (HappyAbsSyn ) +happyIn34 x = unsafeCoerce# x +{-# INLINE happyIn34 #-} +happyOut34 :: (HappyAbsSyn ) -> (DataOrNew) +happyOut34 x = unsafeCoerce# x +{-# INLINE happyOut34 #-} +happyIn35 :: ([Type]) -> (HappyAbsSyn ) +happyIn35 x = unsafeCoerce# x +{-# INLINE happyIn35 #-} +happyOut35 :: (HappyAbsSyn ) -> ([Type]) +happyOut35 x = unsafeCoerce# x +{-# INLINE happyOut35 #-} +happyIn36 :: ([Decl]) -> (HappyAbsSyn ) +happyIn36 x = unsafeCoerce# x +{-# INLINE happyIn36 #-} +happyOut36 :: (HappyAbsSyn ) -> ([Decl]) +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 :: (Decl) -> (HappyAbsSyn ) +happyIn40 x = unsafeCoerce# x +{-# INLINE happyIn40 #-} +happyOut40 :: (HappyAbsSyn ) -> (Decl) +happyOut40 x = unsafeCoerce# x +{-# INLINE happyOut40 #-} +happyIn41 :: (Binds) -> (HappyAbsSyn ) +happyIn41 x = unsafeCoerce# x +{-# INLINE happyIn41 #-} +happyOut41 :: (HappyAbsSyn ) -> (Binds) +happyOut41 x = unsafeCoerce# x +{-# INLINE happyOut41 #-} +happyIn42 :: ([Name]) -> (HappyAbsSyn ) +happyIn42 x = unsafeCoerce# x +{-# INLINE happyIn42 #-} +happyOut42 :: (HappyAbsSyn ) -> ([Name]) +happyOut42 x = unsafeCoerce# x +{-# INLINE happyOut42 #-} +happyIn43 :: (CallConv) -> (HappyAbsSyn ) +happyIn43 x = unsafeCoerce# x +{-# INLINE happyIn43 #-} +happyOut43 :: (HappyAbsSyn ) -> (CallConv) +happyOut43 x = unsafeCoerce# x +{-# INLINE happyOut43 #-} +happyIn44 :: (Safety) -> (HappyAbsSyn ) +happyIn44 x = unsafeCoerce# x +{-# INLINE happyIn44 #-} +happyOut44 :: (HappyAbsSyn ) -> (Safety) +happyOut44 x = unsafeCoerce# x +{-# INLINE happyOut44 #-} +happyIn45 :: ((String, Name, Type)) -> (HappyAbsSyn ) +happyIn45 x = unsafeCoerce# x +{-# INLINE happyIn45 #-} +happyOut45 :: (HappyAbsSyn ) -> ((String, Name, Type)) +happyOut45 x = unsafeCoerce# x +{-# INLINE happyOut45 #-} +happyIn46 :: (Type) -> (HappyAbsSyn ) +happyIn46 x = unsafeCoerce# x +{-# INLINE happyIn46 #-} +happyOut46 :: (HappyAbsSyn ) -> (Type) +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 :: (Type) -> (HappyAbsSyn ) +happyIn49 x = unsafeCoerce# x +{-# INLINE happyIn49 #-} +happyOut49 :: (HappyAbsSyn ) -> (Type) +happyOut49 x = unsafeCoerce# x +{-# INLINE happyOut49 #-} +happyIn50 :: (QName) -> (HappyAbsSyn ) +happyIn50 x = unsafeCoerce# x +{-# INLINE happyIn50 #-} +happyOut50 :: (HappyAbsSyn ) -> (QName) +happyOut50 x = unsafeCoerce# x +{-# INLINE happyOut50 #-} +happyIn51 :: (QName) -> (HappyAbsSyn ) +happyIn51 x = unsafeCoerce# x +{-# INLINE happyIn51 #-} +happyOut51 :: (HappyAbsSyn ) -> (QName) +happyOut51 x = unsafeCoerce# x +{-# INLINE happyOut51 #-} +happyIn52 :: (Type) -> (HappyAbsSyn ) +happyIn52 x = unsafeCoerce# x +{-# INLINE happyIn52 #-} +happyOut52 :: (HappyAbsSyn ) -> (Type) +happyOut52 x = unsafeCoerce# x +{-# INLINE happyOut52 #-} +happyIn53 :: (Context) -> (HappyAbsSyn ) +happyIn53 x = unsafeCoerce# x +{-# INLINE happyIn53 #-} +happyOut53 :: (HappyAbsSyn ) -> (Context) +happyOut53 x = unsafeCoerce# x +{-# INLINE happyOut53 #-} +happyIn54 :: ([Type]) -> (HappyAbsSyn ) +happyIn54 x = unsafeCoerce# x +{-# INLINE happyIn54 #-} +happyOut54 :: (HappyAbsSyn ) -> ([Type]) +happyOut54 x = unsafeCoerce# x +{-# INLINE happyOut54 #-} +happyIn55 :: ([Type]) -> (HappyAbsSyn ) +happyIn55 x = unsafeCoerce# x +{-# INLINE happyIn55 #-} +happyOut55 :: (HappyAbsSyn ) -> ([Type]) +happyOut55 x = unsafeCoerce# x +{-# INLINE happyOut55 #-} +happyIn56 :: ([TyVarBind]) -> (HappyAbsSyn ) +happyIn56 x = unsafeCoerce# x +{-# INLINE happyIn56 #-} +happyOut56 :: (HappyAbsSyn ) -> ([TyVarBind]) +happyOut56 x = unsafeCoerce# x +{-# INLINE happyOut56 #-} +happyIn57 :: (TyVarBind) -> (HappyAbsSyn ) +happyIn57 x = unsafeCoerce# x +{-# INLINE happyIn57 #-} +happyOut57 :: (HappyAbsSyn ) -> (TyVarBind) +happyOut57 x = unsafeCoerce# x +{-# INLINE happyOut57 #-} +happyIn58 :: ([Name]) -> (HappyAbsSyn ) +happyIn58 x = unsafeCoerce# x +{-# INLINE happyIn58 #-} +happyOut58 :: (HappyAbsSyn ) -> ([Name]) +happyOut58 x = unsafeCoerce# x +{-# INLINE happyOut58 #-} +happyIn59 :: ([FunDep]) -> (HappyAbsSyn ) +happyIn59 x = unsafeCoerce# x +{-# INLINE happyIn59 #-} +happyOut59 :: (HappyAbsSyn ) -> ([FunDep]) +happyOut59 x = unsafeCoerce# x +{-# INLINE happyOut59 #-} +happyIn60 :: ([FunDep]) -> (HappyAbsSyn ) +happyIn60 x = unsafeCoerce# x +{-# INLINE happyIn60 #-} +happyOut60 :: (HappyAbsSyn ) -> ([FunDep]) +happyOut60 x = unsafeCoerce# x +{-# INLINE happyOut60 #-} +happyIn61 :: (FunDep) -> (HappyAbsSyn ) +happyIn61 x = unsafeCoerce# x +{-# INLINE happyIn61 #-} +happyOut61 :: (HappyAbsSyn ) -> (FunDep) +happyOut61 x = unsafeCoerce# x +{-# INLINE happyOut61 #-} +happyIn62 :: ([GadtDecl]) -> (HappyAbsSyn ) +happyIn62 x = unsafeCoerce# x +{-# INLINE happyIn62 #-} +happyOut62 :: (HappyAbsSyn ) -> ([GadtDecl]) +happyOut62 x = unsafeCoerce# x +{-# INLINE happyOut62 #-} +happyIn63 :: ([GadtDecl]) -> (HappyAbsSyn ) +happyIn63 x = unsafeCoerce# x +{-# INLINE happyIn63 #-} +happyOut63 :: (HappyAbsSyn ) -> ([GadtDecl]) +happyOut63 x = unsafeCoerce# x +{-# INLINE happyOut63 #-} +happyIn64 :: ([GadtDecl]) -> (HappyAbsSyn ) +happyIn64 x = unsafeCoerce# x +{-# INLINE happyIn64 #-} +happyOut64 :: (HappyAbsSyn ) -> ([GadtDecl]) +happyOut64 x = unsafeCoerce# x +{-# INLINE happyOut64 #-} +happyIn65 :: (GadtDecl) -> (HappyAbsSyn ) +happyIn65 x = unsafeCoerce# x +{-# INLINE happyIn65 #-} +happyOut65 :: (HappyAbsSyn ) -> (GadtDecl) +happyOut65 x = unsafeCoerce# x +{-# INLINE happyOut65 #-} +happyIn66 :: ([QualConDecl]) -> (HappyAbsSyn ) +happyIn66 x = unsafeCoerce# x +{-# INLINE happyIn66 #-} +happyOut66 :: (HappyAbsSyn ) -> ([QualConDecl]) +happyOut66 x = unsafeCoerce# x +{-# INLINE happyOut66 #-} +happyIn67 :: ([QualConDecl]) -> (HappyAbsSyn ) +happyIn67 x = unsafeCoerce# x +{-# INLINE happyIn67 #-} +happyOut67 :: (HappyAbsSyn ) -> ([QualConDecl]) +happyOut67 x = unsafeCoerce# x +{-# INLINE happyOut67 #-} +happyIn68 :: (QualConDecl) -> (HappyAbsSyn ) +happyIn68 x = unsafeCoerce# x +{-# INLINE happyIn68 #-} +happyOut68 :: (HappyAbsSyn ) -> (QualConDecl) +happyOut68 x = unsafeCoerce# x +{-# INLINE happyOut68 #-} +happyIn69 :: ([TyVarBind]) -> (HappyAbsSyn ) +happyIn69 x = unsafeCoerce# x +{-# INLINE happyIn69 #-} +happyOut69 :: (HappyAbsSyn ) -> ([TyVarBind]) +happyOut69 x = unsafeCoerce# x +{-# INLINE happyOut69 #-} +happyIn70 :: (ConDecl) -> (HappyAbsSyn ) +happyIn70 x = unsafeCoerce# x +{-# INLINE happyIn70 #-} +happyOut70 :: (HappyAbsSyn ) -> (ConDecl) +happyOut70 x = unsafeCoerce# x +{-# INLINE happyOut70 #-} +happyIn71 :: ((Name, [BangType])) -> (HappyAbsSyn ) +happyIn71 x = unsafeCoerce# x +{-# INLINE happyIn71 #-} +happyOut71 :: (HappyAbsSyn ) -> ((Name, [BangType])) +happyOut71 x = unsafeCoerce# x +{-# INLINE happyOut71 #-} +happyIn72 :: ((Name, [BangType])) -> (HappyAbsSyn ) +happyIn72 x = unsafeCoerce# x +{-# INLINE happyIn72 #-} +happyOut72 :: (HappyAbsSyn ) -> ((Name, [BangType])) +happyOut72 x = unsafeCoerce# x +{-# INLINE happyOut72 #-} +happyIn73 :: (BangType) -> (HappyAbsSyn ) +happyIn73 x = unsafeCoerce# x +{-# INLINE happyIn73 #-} +happyOut73 :: (HappyAbsSyn ) -> (BangType) +happyOut73 x = unsafeCoerce# x +{-# INLINE happyOut73 #-} +happyIn74 :: (BangType) -> (HappyAbsSyn ) +happyIn74 x = unsafeCoerce# x +{-# INLINE happyIn74 #-} +happyOut74 :: (HappyAbsSyn ) -> (BangType) +happyOut74 x = unsafeCoerce# x +{-# INLINE happyOut74 #-} +happyIn75 :: ([([Name],BangType)]) -> (HappyAbsSyn ) +happyIn75 x = unsafeCoerce# x +{-# INLINE happyIn75 #-} +happyOut75 :: (HappyAbsSyn ) -> ([([Name],BangType)]) +happyOut75 x = unsafeCoerce# x +{-# INLINE happyOut75 #-} +happyIn76 :: (([Name],BangType)) -> (HappyAbsSyn ) +happyIn76 x = unsafeCoerce# x +{-# INLINE happyIn76 #-} +happyOut76 :: (HappyAbsSyn ) -> (([Name],BangType)) +happyOut76 x = unsafeCoerce# x +{-# INLINE happyOut76 #-} +happyIn77 :: (BangType) -> (HappyAbsSyn ) +happyIn77 x = unsafeCoerce# x +{-# INLINE happyIn77 #-} +happyOut77 :: (HappyAbsSyn ) -> (BangType) +happyOut77 x = unsafeCoerce# x +{-# INLINE happyOut77 #-} +happyIn78 :: ([QName]) -> (HappyAbsSyn ) +happyIn78 x = unsafeCoerce# x +{-# INLINE happyIn78 #-} +happyOut78 :: (HappyAbsSyn ) -> ([QName]) +happyOut78 x = unsafeCoerce# x +{-# INLINE happyOut78 #-} +happyIn79 :: ([QName]) -> (HappyAbsSyn ) +happyIn79 x = unsafeCoerce# x +{-# INLINE happyIn79 #-} +happyOut79 :: (HappyAbsSyn ) -> ([QName]) +happyOut79 x = unsafeCoerce# x +{-# INLINE happyOut79 #-} +happyIn80 :: (Kind) -> (HappyAbsSyn ) +happyIn80 x = unsafeCoerce# x +{-# INLINE happyIn80 #-} +happyOut80 :: (HappyAbsSyn ) -> (Kind) +happyOut80 x = unsafeCoerce# x +{-# INLINE happyOut80 #-} +happyIn81 :: (Kind) -> (HappyAbsSyn ) +happyIn81 x = unsafeCoerce# x +{-# INLINE happyIn81 #-} +happyOut81 :: (HappyAbsSyn ) -> (Kind) +happyOut81 x = unsafeCoerce# x +{-# INLINE happyOut81 #-} +happyIn82 :: (Maybe Kind) -> (HappyAbsSyn ) +happyIn82 x = unsafeCoerce# x +{-# INLINE happyIn82 #-} +happyOut82 :: (HappyAbsSyn ) -> (Maybe Kind) +happyOut82 x = unsafeCoerce# x +{-# INLINE happyOut82 #-} +happyIn83 :: ([ClassDecl]) -> (HappyAbsSyn ) +happyIn83 x = unsafeCoerce# x +{-# INLINE happyIn83 #-} +happyOut83 :: (HappyAbsSyn ) -> ([ClassDecl]) +happyOut83 x = unsafeCoerce# x +{-# INLINE happyOut83 #-} +happyIn84 :: ([ClassDecl]) -> (HappyAbsSyn ) +happyIn84 x = unsafeCoerce# x +{-# INLINE happyIn84 #-} +happyOut84 :: (HappyAbsSyn ) -> ([ClassDecl]) +happyOut84 x = unsafeCoerce# x +{-# INLINE happyOut84 #-} +happyIn85 :: ([ClassDecl]) -> (HappyAbsSyn ) +happyIn85 x = unsafeCoerce# x +{-# INLINE happyIn85 #-} +happyOut85 :: (HappyAbsSyn ) -> ([ClassDecl]) +happyOut85 x = unsafeCoerce# x +{-# INLINE happyOut85 #-} +happyIn86 :: ([ClassDecl]) -> (HappyAbsSyn ) +happyIn86 x = unsafeCoerce# x +{-# INLINE happyIn86 #-} +happyOut86 :: (HappyAbsSyn ) -> ([ClassDecl]) +happyOut86 x = unsafeCoerce# x +{-# INLINE happyOut86 #-} +happyIn87 :: (ClassDecl) -> (HappyAbsSyn ) +happyIn87 x = unsafeCoerce# x +{-# INLINE happyIn87 #-} +happyOut87 :: (HappyAbsSyn ) -> (ClassDecl) +happyOut87 x = unsafeCoerce# x +{-# INLINE happyOut87 #-} +happyIn88 :: (ClassDecl) -> (HappyAbsSyn ) +happyIn88 x = unsafeCoerce# x +{-# INLINE happyIn88 #-} +happyOut88 :: (HappyAbsSyn ) -> (ClassDecl) +happyOut88 x = unsafeCoerce# x +{-# INLINE happyOut88 #-} +happyIn89 :: ([InstDecl]) -> (HappyAbsSyn ) +happyIn89 x = unsafeCoerce# x +{-# INLINE happyIn89 #-} +happyOut89 :: (HappyAbsSyn ) -> ([InstDecl]) +happyOut89 x = unsafeCoerce# x +{-# INLINE happyOut89 #-} +happyIn90 :: ([InstDecl]) -> (HappyAbsSyn ) +happyIn90 x = unsafeCoerce# x +{-# INLINE happyIn90 #-} +happyOut90 :: (HappyAbsSyn ) -> ([InstDecl]) +happyOut90 x = unsafeCoerce# x +{-# INLINE happyOut90 #-} +happyIn91 :: ([InstDecl]) -> (HappyAbsSyn ) +happyIn91 x = unsafeCoerce# x +{-# INLINE happyIn91 #-} +happyOut91 :: (HappyAbsSyn ) -> ([InstDecl]) +happyOut91 x = unsafeCoerce# x +{-# INLINE happyOut91 #-} +happyIn92 :: (InstDecl) -> (HappyAbsSyn ) +happyIn92 x = unsafeCoerce# x +{-# INLINE happyIn92 #-} +happyOut92 :: (HappyAbsSyn ) -> (InstDecl) +happyOut92 x = unsafeCoerce# x +{-# INLINE happyOut92 #-} +happyIn93 :: (InstDecl) -> (HappyAbsSyn ) +happyIn93 x = unsafeCoerce# x +{-# INLINE happyIn93 #-} +happyOut93 :: (HappyAbsSyn ) -> (InstDecl) +happyOut93 x = unsafeCoerce# x +{-# INLINE happyOut93 #-} +happyIn94 :: (Decl) -> (HappyAbsSyn ) +happyIn94 x = unsafeCoerce# x +{-# INLINE happyIn94 #-} +happyOut94 :: (HappyAbsSyn ) -> (Decl) +happyOut94 x = unsafeCoerce# x +{-# INLINE happyOut94 #-} +happyIn95 :: (Binds) -> (HappyAbsSyn ) +happyIn95 x = unsafeCoerce# x +{-# INLINE happyIn95 #-} +happyOut95 :: (HappyAbsSyn ) -> (Binds) +happyOut95 x = unsafeCoerce# x +{-# INLINE happyOut95 #-} +happyIn96 :: (Rhs) -> (HappyAbsSyn ) +happyIn96 x = unsafeCoerce# x +{-# INLINE happyIn96 #-} +happyOut96 :: (HappyAbsSyn ) -> (Rhs) +happyOut96 x = unsafeCoerce# x +{-# INLINE happyOut96 #-} +happyIn97 :: ([GuardedRhs]) -> (HappyAbsSyn ) +happyIn97 x = unsafeCoerce# x +{-# INLINE happyIn97 #-} +happyOut97 :: (HappyAbsSyn ) -> ([GuardedRhs]) +happyOut97 x = unsafeCoerce# x +{-# INLINE happyOut97 #-} +happyIn98 :: (GuardedRhs) -> (HappyAbsSyn ) +happyIn98 x = unsafeCoerce# x +{-# INLINE happyIn98 #-} +happyOut98 :: (HappyAbsSyn ) -> (GuardedRhs) +happyOut98 x = unsafeCoerce# x +{-# INLINE happyOut98 #-} +happyIn99 :: (Exp) -> (HappyAbsSyn ) +happyIn99 x = unsafeCoerce# x +{-# INLINE happyIn99 #-} +happyOut99 :: (HappyAbsSyn ) -> (Exp) +happyOut99 x = unsafeCoerce# x +{-# INLINE happyOut99 #-} +happyIn100 :: (PExp) -> (HappyAbsSyn ) +happyIn100 x = unsafeCoerce# x +{-# INLINE happyIn100 #-} +happyOut100 :: (HappyAbsSyn ) -> (PExp) +happyOut100 x = unsafeCoerce# x +{-# INLINE happyOut100 #-} +happyIn101 :: (PExp) -> (HappyAbsSyn ) +happyIn101 x = unsafeCoerce# x +{-# INLINE happyIn101 #-} +happyOut101 :: (HappyAbsSyn ) -> (PExp) +happyOut101 x = unsafeCoerce# x +{-# INLINE happyOut101 #-} +happyIn102 :: (PExp) -> (HappyAbsSyn ) +happyIn102 x = unsafeCoerce# x +{-# INLINE happyIn102 #-} +happyOut102 :: (HappyAbsSyn ) -> (PExp) +happyOut102 x = unsafeCoerce# x +{-# INLINE happyOut102 #-} +happyIn103 :: (PExp) -> (HappyAbsSyn ) +happyIn103 x = unsafeCoerce# x +{-# INLINE happyIn103 #-} +happyOut103 :: (HappyAbsSyn ) -> (PExp) +happyOut103 x = unsafeCoerce# x +{-# INLINE happyOut103 #-} +happyIn104 :: (PExp) -> (HappyAbsSyn ) +happyIn104 x = unsafeCoerce# x +{-# INLINE happyIn104 #-} +happyOut104 :: (HappyAbsSyn ) -> (PExp) +happyOut104 x = unsafeCoerce# x +{-# INLINE happyOut104 #-} +happyIn105 :: (PExp) -> (HappyAbsSyn ) +happyIn105 x = unsafeCoerce# x +{-# INLINE happyIn105 #-} +happyOut105 :: (HappyAbsSyn ) -> (PExp) +happyOut105 x = unsafeCoerce# x +{-# INLINE happyOut105 #-} +happyIn106 :: (PExp) -> (HappyAbsSyn ) +happyIn106 x = unsafeCoerce# x +{-# INLINE happyIn106 #-} +happyOut106 :: (HappyAbsSyn ) -> (PExp) +happyOut106 x = unsafeCoerce# x +{-# INLINE happyOut106 #-} +happyIn107 :: ([Pat]) -> (HappyAbsSyn ) +happyIn107 x = unsafeCoerce# x +{-# INLINE happyIn107 #-} +happyOut107 :: (HappyAbsSyn ) -> ([Pat]) +happyOut107 x = unsafeCoerce# x +{-# INLINE happyOut107 #-} +happyIn108 :: (Pat) -> (HappyAbsSyn ) +happyIn108 x = unsafeCoerce# x +{-# INLINE happyIn108 #-} +happyOut108 :: (HappyAbsSyn ) -> (Pat) +happyOut108 x = unsafeCoerce# x +{-# INLINE happyOut108 #-} +happyIn109 :: (PExp) -> (HappyAbsSyn ) +happyIn109 x = unsafeCoerce# x +{-# INLINE happyIn109 #-} +happyOut109 :: (HappyAbsSyn ) -> (PExp) +happyOut109 x = unsafeCoerce# x +{-# INLINE happyOut109 #-} +happyIn110 :: (PExp) -> (HappyAbsSyn ) +happyIn110 x = unsafeCoerce# x +{-# INLINE happyIn110 #-} +happyOut110 :: (HappyAbsSyn ) -> (PExp) +happyOut110 x = unsafeCoerce# x +{-# INLINE happyOut110 #-} +happyIn111 :: (PExp) -> (HappyAbsSyn ) +happyIn111 x = unsafeCoerce# x +{-# INLINE happyIn111 #-} +happyOut111 :: (HappyAbsSyn ) -> (PExp) +happyOut111 x = unsafeCoerce# x +{-# INLINE happyOut111 #-} +happyIn112 :: (Int) -> (HappyAbsSyn ) +happyIn112 x = unsafeCoerce# x +{-# INLINE happyIn112 #-} +happyOut112 :: (HappyAbsSyn ) -> (Int) +happyOut112 x = unsafeCoerce# x +{-# INLINE happyOut112 #-} +happyIn113 :: ([PExp]) -> (HappyAbsSyn ) +happyIn113 x = unsafeCoerce# x +{-# INLINE happyIn113 #-} +happyOut113 :: (HappyAbsSyn ) -> ([PExp]) +happyOut113 x = unsafeCoerce# x +{-# INLINE happyOut113 #-} +happyIn114 :: ([PExp]) -> (HappyAbsSyn ) +happyIn114 x = unsafeCoerce# x +{-# INLINE happyIn114 #-} +happyOut114 :: (HappyAbsSyn ) -> ([PExp]) +happyOut114 x = unsafeCoerce# x +{-# INLINE happyOut114 #-} +happyIn115 :: (PExp) -> (HappyAbsSyn ) +happyIn115 x = unsafeCoerce# x +{-# INLINE happyIn115 #-} +happyOut115 :: (HappyAbsSyn ) -> (PExp) +happyOut115 x = unsafeCoerce# x +{-# INLINE happyOut115 #-} +happyIn116 :: (PExp) -> (HappyAbsSyn ) +happyIn116 x = unsafeCoerce# x +{-# INLINE happyIn116 #-} +happyOut116 :: (HappyAbsSyn ) -> (PExp) +happyOut116 x = unsafeCoerce# x +{-# INLINE happyOut116 #-} +happyIn117 :: ([PExp]) -> (HappyAbsSyn ) +happyIn117 x = unsafeCoerce# x +{-# INLINE happyIn117 #-} +happyOut117 :: (HappyAbsSyn ) -> ([PExp]) +happyOut117 x = unsafeCoerce# x +{-# INLINE happyOut117 #-} +happyIn118 :: (PExp) -> (HappyAbsSyn ) +happyIn118 x = unsafeCoerce# x +{-# INLINE happyIn118 #-} +happyOut118 :: (HappyAbsSyn ) -> (PExp) +happyOut118 x = unsafeCoerce# x +{-# INLINE happyOut118 #-} +happyIn119 :: (XName) -> (HappyAbsSyn ) +happyIn119 x = unsafeCoerce# x +{-# INLINE happyIn119 #-} +happyOut119 :: (HappyAbsSyn ) -> (XName) +happyOut119 x = unsafeCoerce# x +{-# INLINE happyOut119 #-} +happyIn120 :: (String) -> (HappyAbsSyn ) +happyIn120 x = unsafeCoerce# x +{-# INLINE happyIn120 #-} +happyOut120 :: (HappyAbsSyn ) -> (String) +happyOut120 x = unsafeCoerce# x +{-# INLINE happyOut120 #-} +happyIn121 :: ([ParseXAttr]) -> (HappyAbsSyn ) +happyIn121 x = unsafeCoerce# x +{-# INLINE happyIn121 #-} +happyOut121 :: (HappyAbsSyn ) -> ([ParseXAttr]) +happyOut121 x = unsafeCoerce# x +{-# INLINE happyOut121 #-} +happyIn122 :: (ParseXAttr) -> (HappyAbsSyn ) +happyIn122 x = unsafeCoerce# x +{-# INLINE happyIn122 #-} +happyOut122 :: (HappyAbsSyn ) -> (ParseXAttr) +happyOut122 x = unsafeCoerce# x +{-# INLINE happyOut122 #-} +happyIn123 :: (Maybe PExp) -> (HappyAbsSyn ) +happyIn123 x = unsafeCoerce# x +{-# INLINE happyIn123 #-} +happyOut123 :: (HappyAbsSyn ) -> (Maybe PExp) +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 :: ([Stmt]) -> (HappyAbsSyn ) +happyIn127 x = unsafeCoerce# x +{-# INLINE happyIn127 #-} +happyOut127 :: (HappyAbsSyn ) -> ([Stmt]) +happyOut127 x = unsafeCoerce# x +{-# INLINE happyOut127 #-} +happyIn128 :: (Stmt) -> (HappyAbsSyn ) +happyIn128 x = unsafeCoerce# x +{-# INLINE happyIn128 #-} +happyOut128 :: (HappyAbsSyn ) -> (Stmt) +happyOut128 x = unsafeCoerce# x +{-# INLINE happyOut128 #-} +happyIn129 :: ([Alt]) -> (HappyAbsSyn ) +happyIn129 x = unsafeCoerce# x +{-# INLINE happyIn129 #-} +happyOut129 :: (HappyAbsSyn ) -> ([Alt]) +happyOut129 x = unsafeCoerce# x +{-# INLINE happyOut129 #-} +happyIn130 :: ([Alt]) -> (HappyAbsSyn ) +happyIn130 x = unsafeCoerce# x +{-# INLINE happyIn130 #-} +happyOut130 :: (HappyAbsSyn ) -> ([Alt]) +happyOut130 x = unsafeCoerce# x +{-# INLINE happyOut130 #-} +happyIn131 :: ([Alt]) -> (HappyAbsSyn ) +happyIn131 x = unsafeCoerce# x +{-# INLINE happyIn131 #-} +happyOut131 :: (HappyAbsSyn ) -> ([Alt]) +happyOut131 x = unsafeCoerce# x +{-# INLINE happyOut131 #-} +happyIn132 :: (Alt) -> (HappyAbsSyn ) +happyIn132 x = unsafeCoerce# x +{-# INLINE happyIn132 #-} +happyOut132 :: (HappyAbsSyn ) -> (Alt) +happyOut132 x = unsafeCoerce# x +{-# INLINE happyOut132 #-} +happyIn133 :: (GuardedAlts) -> (HappyAbsSyn ) +happyIn133 x = unsafeCoerce# x +{-# INLINE happyIn133 #-} +happyOut133 :: (HappyAbsSyn ) -> (GuardedAlts) +happyOut133 x = unsafeCoerce# x +{-# INLINE happyOut133 #-} +happyIn134 :: ([GuardedAlt]) -> (HappyAbsSyn ) +happyIn134 x = unsafeCoerce# x +{-# INLINE happyIn134 #-} +happyOut134 :: (HappyAbsSyn ) -> ([GuardedAlt]) +happyOut134 x = unsafeCoerce# x +{-# INLINE happyOut134 #-} +happyIn135 :: (GuardedAlt) -> (HappyAbsSyn ) +happyIn135 x = unsafeCoerce# x +{-# INLINE happyIn135 #-} +happyOut135 :: (HappyAbsSyn ) -> (GuardedAlt) +happyOut135 x = unsafeCoerce# x +{-# INLINE happyOut135 #-} +happyIn136 :: (Pat) -> (HappyAbsSyn ) +happyIn136 x = unsafeCoerce# x +{-# INLINE happyIn136 #-} +happyOut136 :: (HappyAbsSyn ) -> (Pat) +happyOut136 x = unsafeCoerce# x +{-# INLINE happyOut136 #-} +happyIn137 :: ([Stmt]) -> (HappyAbsSyn ) +happyIn137 x = unsafeCoerce# x +{-# INLINE happyIn137 #-} +happyOut137 :: (HappyAbsSyn ) -> ([Stmt]) +happyOut137 x = unsafeCoerce# x +{-# INLINE happyOut137 #-} +happyIn138 :: ([Stmt]) -> (HappyAbsSyn ) +happyIn138 x = unsafeCoerce# x +{-# INLINE happyIn138 #-} +happyOut138 :: (HappyAbsSyn ) -> ([Stmt]) +happyOut138 x = unsafeCoerce# x +{-# INLINE happyOut138 #-} +happyIn139 :: ([PFieldUpdate]) -> (HappyAbsSyn ) +happyIn139 x = unsafeCoerce# x +{-# INLINE happyIn139 #-} +happyOut139 :: (HappyAbsSyn ) -> ([PFieldUpdate]) +happyOut139 x = unsafeCoerce# x +{-# INLINE happyOut139 #-} +happyIn140 :: (PFieldUpdate) -> (HappyAbsSyn ) +happyIn140 x = unsafeCoerce# x +{-# INLINE happyIn140 #-} +happyOut140 :: (HappyAbsSyn ) -> (PFieldUpdate) +happyOut140 x = unsafeCoerce# x +{-# INLINE happyOut140 #-} +happyIn141 :: ([IPBind]) -> (HappyAbsSyn ) +happyIn141 x = unsafeCoerce# x +{-# INLINE happyIn141 #-} +happyOut141 :: (HappyAbsSyn ) -> ([IPBind]) +happyOut141 x = unsafeCoerce# x +{-# INLINE happyOut141 #-} +happyIn142 :: ([IPBind]) -> (HappyAbsSyn ) +happyIn142 x = unsafeCoerce# x +{-# INLINE happyIn142 #-} +happyOut142 :: (HappyAbsSyn ) -> ([IPBind]) +happyOut142 x = unsafeCoerce# x +{-# INLINE happyOut142 #-} +happyIn143 :: (IPBind) -> (HappyAbsSyn ) +happyIn143 x = unsafeCoerce# x +{-# INLINE happyIn143 #-} +happyOut143 :: (HappyAbsSyn ) -> (IPBind) +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 :: (Name) -> (HappyAbsSyn ) +happyIn145 x = unsafeCoerce# x +{-# INLINE happyIn145 #-} +happyOut145 :: (HappyAbsSyn ) -> (Name) +happyOut145 x = unsafeCoerce# x +{-# INLINE happyOut145 #-} +happyIn146 :: (Name) -> (HappyAbsSyn ) +happyIn146 x = unsafeCoerce# x +{-# INLINE happyIn146 #-} +happyOut146 :: (HappyAbsSyn ) -> (Name) +happyOut146 x = unsafeCoerce# x +{-# INLINE happyOut146 #-} +happyIn147 :: (QName) -> (HappyAbsSyn ) +happyIn147 x = unsafeCoerce# x +{-# INLINE happyIn147 #-} +happyOut147 :: (HappyAbsSyn ) -> (QName) +happyOut147 x = unsafeCoerce# x +{-# INLINE happyOut147 #-} +happyIn148 :: (IPName) -> (HappyAbsSyn ) +happyIn148 x = unsafeCoerce# x +{-# INLINE happyIn148 #-} +happyOut148 :: (HappyAbsSyn ) -> (IPName) +happyOut148 x = unsafeCoerce# x +{-# INLINE happyOut148 #-} +happyIn149 :: (Name) -> (HappyAbsSyn ) +happyIn149 x = unsafeCoerce# x +{-# INLINE happyIn149 #-} +happyOut149 :: (HappyAbsSyn ) -> (Name) +happyOut149 x = unsafeCoerce# x +{-# INLINE happyOut149 #-} +happyIn150 :: (QName) -> (HappyAbsSyn ) +happyIn150 x = unsafeCoerce# x +{-# INLINE happyIn150 #-} +happyOut150 :: (HappyAbsSyn ) -> (QName) +happyOut150 x = unsafeCoerce# x +{-# INLINE happyOut150 #-} +happyIn151 :: (Name) -> (HappyAbsSyn ) +happyIn151 x = unsafeCoerce# x +{-# INLINE happyIn151 #-} +happyOut151 :: (HappyAbsSyn ) -> (Name) +happyOut151 x = unsafeCoerce# x +{-# INLINE happyOut151 #-} +happyIn152 :: (QName) -> (HappyAbsSyn ) +happyIn152 x = unsafeCoerce# x +{-# INLINE happyIn152 #-} +happyOut152 :: (HappyAbsSyn ) -> (QName) +happyOut152 x = unsafeCoerce# x +{-# INLINE happyOut152 #-} +happyIn153 :: (QName) -> (HappyAbsSyn ) +happyIn153 x = unsafeCoerce# x +{-# INLINE happyIn153 #-} +happyOut153 :: (HappyAbsSyn ) -> (QName) +happyOut153 x = unsafeCoerce# x +{-# INLINE happyOut153 #-} +happyIn154 :: (Name) -> (HappyAbsSyn ) +happyIn154 x = unsafeCoerce# x +{-# INLINE happyIn154 #-} +happyOut154 :: (HappyAbsSyn ) -> (Name) +happyOut154 x = unsafeCoerce# x +{-# INLINE happyOut154 #-} +happyIn155 :: (QName) -> (HappyAbsSyn ) +happyIn155 x = unsafeCoerce# x +{-# INLINE happyIn155 #-} +happyOut155 :: (HappyAbsSyn ) -> (QName) +happyOut155 x = unsafeCoerce# x +{-# INLINE happyOut155 #-} +happyIn156 :: (Op) -> (HappyAbsSyn ) +happyIn156 x = unsafeCoerce# x +{-# INLINE happyIn156 #-} +happyOut156 :: (HappyAbsSyn ) -> (Op) +happyOut156 x = unsafeCoerce# x +{-# INLINE happyOut156 #-} +happyIn157 :: (QOp) -> (HappyAbsSyn ) +happyIn157 x = unsafeCoerce# x +{-# INLINE happyIn157 #-} +happyOut157 :: (HappyAbsSyn ) -> (QOp) +happyOut157 x = unsafeCoerce# x +{-# INLINE happyOut157 #-} +happyIn158 :: (QOp) -> (HappyAbsSyn ) +happyIn158 x = unsafeCoerce# x +{-# INLINE happyIn158 #-} +happyOut158 :: (HappyAbsSyn ) -> (QOp) +happyOut158 x = unsafeCoerce# x +{-# INLINE happyOut158 #-} +happyIn159 :: (QName) -> (HappyAbsSyn ) +happyIn159 x = unsafeCoerce# x +{-# INLINE happyIn159 #-} +happyOut159 :: (HappyAbsSyn ) -> (QName) +happyOut159 x = unsafeCoerce# x +{-# INLINE happyOut159 #-} +happyIn160 :: (QName) -> (HappyAbsSyn ) +happyIn160 x = unsafeCoerce# x +{-# INLINE happyIn160 #-} +happyOut160 :: (HappyAbsSyn ) -> (QName) +happyOut160 x = unsafeCoerce# x +{-# INLINE happyOut160 #-} +happyIn161 :: (Name) -> (HappyAbsSyn ) +happyIn161 x = unsafeCoerce# x +{-# INLINE happyIn161 #-} +happyOut161 :: (HappyAbsSyn ) -> (Name) +happyOut161 x = unsafeCoerce# x +{-# INLINE happyOut161 #-} +happyIn162 :: (Name) -> (HappyAbsSyn ) +happyIn162 x = unsafeCoerce# x +{-# INLINE happyIn162 #-} +happyOut162 :: (HappyAbsSyn ) -> (Name) +happyOut162 x = unsafeCoerce# x +{-# INLINE happyOut162 #-} +happyIn163 :: (IPName) -> (HappyAbsSyn ) +happyIn163 x = unsafeCoerce# x +{-# INLINE happyIn163 #-} +happyOut163 :: (HappyAbsSyn ) -> (IPName) +happyOut163 x = unsafeCoerce# x +{-# INLINE happyOut163 #-} +happyIn164 :: (QName) -> (HappyAbsSyn ) +happyIn164 x = unsafeCoerce# x +{-# INLINE happyIn164 #-} +happyOut164 :: (HappyAbsSyn ) -> (QName) +happyOut164 x = unsafeCoerce# x +{-# INLINE happyOut164 #-} +happyIn165 :: (Name) -> (HappyAbsSyn ) +happyIn165 x = unsafeCoerce# x +{-# INLINE happyIn165 #-} +happyOut165 :: (HappyAbsSyn ) -> (Name) +happyOut165 x = unsafeCoerce# x +{-# INLINE happyOut165 #-} +happyIn166 :: (QName) -> (HappyAbsSyn ) +happyIn166 x = unsafeCoerce# x +{-# INLINE happyIn166 #-} +happyOut166 :: (HappyAbsSyn ) -> (QName) +happyOut166 x = unsafeCoerce# x +{-# INLINE happyOut166 #-} +happyIn167 :: (Name) -> (HappyAbsSyn ) +happyIn167 x = unsafeCoerce# x +{-# INLINE happyIn167 #-} +happyOut167 :: (HappyAbsSyn ) -> (Name) +happyOut167 x = unsafeCoerce# x +{-# INLINE happyOut167 #-} +happyIn168 :: (QName) -> (HappyAbsSyn ) +happyIn168 x = unsafeCoerce# x +{-# INLINE happyIn168 #-} +happyOut168 :: (HappyAbsSyn ) -> (QName) +happyOut168 x = unsafeCoerce# x +{-# INLINE happyOut168 #-} +happyIn169 :: (QName) -> (HappyAbsSyn ) +happyIn169 x = unsafeCoerce# x +{-# INLINE happyIn169 #-} +happyOut169 :: (HappyAbsSyn ) -> (QName) +happyOut169 x = unsafeCoerce# x +{-# INLINE happyOut169 #-} +happyIn170 :: (Name) -> (HappyAbsSyn ) +happyIn170 x = unsafeCoerce# x +{-# INLINE happyIn170 #-} +happyOut170 :: (HappyAbsSyn ) -> (Name) +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 :: (QName) -> (HappyAbsSyn ) +happyIn172 x = unsafeCoerce# x +{-# INLINE happyIn172 #-} +happyOut172 :: (HappyAbsSyn ) -> (QName) +happyOut172 x = unsafeCoerce# x +{-# INLINE happyOut172 #-} +happyIn173 :: (Literal) -> (HappyAbsSyn ) +happyIn173 x = unsafeCoerce# x +{-# INLINE happyIn173 #-} +happyOut173 :: (HappyAbsSyn ) -> (Literal) +happyOut173 x = unsafeCoerce# x +{-# INLINE happyOut173 #-} +happyIn174 :: (SrcLoc) -> (HappyAbsSyn ) +happyIn174 x = unsafeCoerce# x +{-# INLINE happyIn174 #-} +happyOut174 :: (HappyAbsSyn ) -> (SrcLoc) +happyOut174 x = unsafeCoerce# x +{-# INLINE happyOut174 #-} +happyIn175 :: (()) -> (HappyAbsSyn ) +happyIn175 x = unsafeCoerce# x +{-# INLINE happyIn175 #-} +happyOut175 :: (HappyAbsSyn ) -> (()) +happyOut175 x = unsafeCoerce# x +{-# INLINE happyOut175 #-} +happyIn176 :: (()) -> (HappyAbsSyn ) +happyIn176 x = unsafeCoerce# x +{-# INLINE happyIn176 #-} +happyOut176 :: (HappyAbsSyn ) -> (()) +happyOut176 x = unsafeCoerce# x +{-# INLINE happyOut176 #-} +happyIn177 :: (ModuleName) -> (HappyAbsSyn ) +happyIn177 x = unsafeCoerce# x +{-# INLINE happyIn177 #-} +happyOut177 :: (HappyAbsSyn ) -> (ModuleName) +happyOut177 x = unsafeCoerce# x +{-# INLINE happyOut177 #-} +happyIn178 :: (Name) -> (HappyAbsSyn ) +happyIn178 x = unsafeCoerce# x +{-# INLINE happyIn178 #-} +happyOut178 :: (HappyAbsSyn ) -> (Name) +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 :: (QName) -> (HappyAbsSyn ) +happyIn180 x = unsafeCoerce# x +{-# INLINE happyIn180 #-} +happyOut180 :: (HappyAbsSyn ) -> (QName) +happyOut180 x = unsafeCoerce# x +{-# INLINE happyOut180 #-} +happyIn181 :: (Name) -> (HappyAbsSyn ) +happyIn181 x = unsafeCoerce# x +{-# INLINE happyIn181 #-} +happyOut181 :: (HappyAbsSyn ) -> (Name) +happyOut181 x = unsafeCoerce# x +{-# INLINE happyOut181 #-} +happyIn182 :: (QName) -> (HappyAbsSyn ) +happyIn182 x = unsafeCoerce# x +{-# INLINE happyIn182 #-} +happyOut182 :: (HappyAbsSyn ) -> (QName) +happyOut182 x = unsafeCoerce# x +{-# INLINE happyOut182 #-} +happyIn183 :: (Name) -> (HappyAbsSyn ) +happyIn183 x = unsafeCoerce# x +{-# INLINE happyIn183 #-} +happyOut183 :: (HappyAbsSyn ) -> (Name) +happyOut183 x = unsafeCoerce# x +{-# INLINE happyOut183 #-} +happyInTok :: Token -> (HappyAbsSyn ) +happyInTok x = unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn ) -> Token +happyOutTok x = unsafeCoerce# x +{-# INLINE happyOutTok #-} + + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\x15\x06\x00\x00\x00\x00\x14\x06\xef\x05\x00\x00\x7a\x00\x00\x00\x11\x06\x62\x00\x00\x00\x00\x00\x00\x00\x14\x01\xf9\x04\x36\x06\x00\x00\x00\x00\x00\x00\x3c\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x06\x00\x00\x8f\x05\x1f\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\x00\x00\x00\x00\xb5\x06\x00\x00\x00\x00\x14\x01\xb7\x14\xea\x05\x00\x00\x34\x19\x31\x06\x27\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x06\x00\x00\x00\x00\x00\x00\x00\x00\x50\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x04\x00\x00\x1c\x06\x00\x00\x1b\x06\x00\x00\x00\x00\x0e\x06\x00\x00\xba\x04\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x05\x7c\x03\x00\x00\x00\x00\x5b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x05\x1d\x0d\x00\x00\xed\x15\x36\x13\x00\x00\x36\x13\x36\x13\x36\x13\x44\x18\x00\x00\x07\x1a\xe3\x19\x36\x13\x00\x00\x1f\x06\x5f\x17\x0f\x02\x89\x14\x00\x00\xa5\x15\x00\x00\x00\x00\xd3\x02\x00\x00\xed\x15\x36\x13\xec\xff\x36\x13\x44\x18\xd6\x05\x0f\x06\xd0\x05\x07\x06\xb9\x05\x00\x00\x00\x00\x00\x00\x44\x18\x04\x06\x00\x00\x23\x18\x53\x06\x03\x06\xf1\x05\x03\x06\x00\x00\x00\x00\x00\x00\x00\x00\x17\x07\xec\x05\x98\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x16\x5c\x18\xfc\x17\x5c\x18\x94\x19\x00\x00\xbb\x0c\xbb\x0c\x00\x00\x00\x00\x35\x16\xb4\x05\xee\x05\xeb\x05\x00\x00\xc4\x04\x00\x00\x00\x00\xdb\x17\x5c\x18\xdb\x17\xe5\x05\xac\x05\x00\x00\x00\x00\x61\x10\x00\x00\x00\x00\x36\x13\xed\x05\x86\x04\x86\x04\xf6\x05\x00\x00\xa5\x15\xed\x15\xed\x15\x00\x00\xa5\x05\xe1\x05\x00\x00\x00\x00\x00\x00\x02\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x05\x00\x00\x00\x00\x00\x00\x00\x00\x39\x15\x00\x00\x00\x00\x36\x13\x00\x00\x00\x00\x00\x00\x4a\x0a\xdb\x17\x0a\x00\xdb\x17\x49\x02\x00\x00\xc7\x05\x00\x00\x00\x00\x80\x01\xe3\x05\x00\x00\x00\x00\x75\x03\x00\x00\xc6\x05\xc5\x05\x7b\x05\xc4\x05\xdf\x05\xcb\x05\xde\x01\x00\x00\x79\x03\xd4\x05\xc8\x05\x00\x00\x53\x01\x18\x03\x05\x03\xda\x05\x00\x00\x00\x00\x36\x13\xd8\x05\xd3\x05\x00\x00\x00\x00\xcf\x05\xce\x05\x00\x00\x00\x00\x39\x15\xcd\x05\xa5\x15\xbe\x05\xbd\x05\x14\x01\x00\x00\x00\x00\xed\x15\x60\x08\x00\x00\x00\x00\xbf\x19\xb8\x05\x59\x19\x00\x00\x00\x00\x00\x00\x93\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x02\x00\x00\xb6\x05\x11\x03\x00\x00\xaa\x05\x00\x00\x00\x00\x2d\x04\x00\x00\xa8\x05\xa1\x05\x00\x00\x00\x00\xa9\x05\x00\x00\x00\x00\x36\x13\x00\x00\x00\x00\x00\x00\x36\x13\x36\x13\x36\x13\x00\x00\x36\x13\x59\x0c\xd4\x12\x72\x12\x00\x00\x10\x12\x00\x00\x00\x00\x91\x13\x00\x00\x00\x00\x1f\x01\xa6\x05\x00\x00\x22\x02\x00\x00\xa4\x05\x00\x00\x9a\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x07\x0a\x00\x66\x05\x58\x05\x7c\x01\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x8d\x05\x10\x12\x00\x00\x00\x00\x00\x00\x93\x05\x00\x00\x00\x00\x79\x07\x55\x03\x00\x00\x00\x00\x80\x0e\x00\x00\x56\x05\x00\x00\x00\x00\x43\x05\xed\x15\xae\x11\x00\x00\x8c\x05\x3f\x05\x00\x00\x79\x05\x7d\x05\x73\x05\x00\x00\x72\x05\x00\x00\x42\x05\xac\x0a\x45\x19\x5c\x18\x00\x00\x76\x05\x00\x00\x45\x19\x00\x00\x45\x19\x00\x00\x00\x00\xc8\x15\x45\x19\x45\x19\x75\x05\x27\x14\x00\x00\x67\x05\xf7\x0b\x6d\x05\x1f\x01\x60\x05\x5e\x05\x55\x05\x00\x00\x8a\x01\x62\x05\x75\x02\x68\x05\x45\x19\xdb\x17\x00\x00\x45\x19\x00\x00\x00\x00\x7c\x01\x00\x00\x5c\x18\x00\x00\x00\x00\xdb\x17\x00\x00\x60\x00\x00\x00\x00\x00\x49\x05\xab\x09\xfa\x18\x00\x00\x5c\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x05\xdb\x17\x31\x00\xab\x04\x5c\x18\x00\x00\x00\x00\x2d\x16\x5d\x05\x00\x00\x00\x00\x52\x05\x00\x00\x00\x00\x00\x00\xdb\x17\x00\x00\x5d\x15\x00\x00\x00\x00\x53\x11\x49\x09\x54\x05\x53\x05\x1f\x01\x1f\x01\x53\x11\x00\x00\x46\x05\x00\x00\x44\x0f\xc3\x01\x80\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x01\x00\x00\x00\x00\x50\x05\x00\x00\x51\x05\x38\x05\x00\x00\x09\x05\x00\x00\x30\x05\x7c\x01\x00\x00\x00\x00\x3e\x05\x00\x00\x0d\x03\x05\x05\xf0\x04\x34\x05\x32\x05\x49\x02\x00\x00\x00\x00\x18\x05\xa7\x01\x00\x00\x31\x05\x00\x00\x28\x05\x00\x00\x1f\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x14\x00\x00\x00\x00\x00\x00\x14\x01\x53\x11\x53\x11\x00\x00\x24\x09\x00\x00\x1b\x05\x00\x00\xbf\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x01\xee\x04\x6f\x04\x95\x0b\xf1\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x05\x00\x00\x00\x00\x00\x00\xbd\x02\x00\x00\x00\x00\x00\x00\x10\x05\x7c\x01\xe6\x18\x00\x00\x00\x00\x00\x00\xcd\x04\xfc\x04\x8f\x10\x00\x00\x00\x05\xff\x04\x45\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x10\xbe\x04\x00\x00\xcb\x0f\x00\x00\xfa\x04\xf6\x04\x1f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x04\x00\x00\x00\x00\x00\x00\xf1\x04\x00\x00\x00\x00\xe0\x04\xe7\x08\xdc\x04\x1f\x01\x00\x00\x00\x00\xcb\x0f\x33\x0b\x00\x00\x00\x00\xdb\x04\x00\x00\x00\x00\xd5\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x0f\x7c\x01\x1d\x1a\xcc\x05\x00\x00\xc1\x07\xd0\x04\x1f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x55\x14\x00\x00\x07\x0f\xc2\x04\xa4\x04\xcc\x04\xd1\x0a\xcc\x04\x00\x00\x45\x19\x00\x00\x00\x00\x07\x0f\x00\x00\xc2\x08\xf6\x16\xae\x04\x00\x00\x00\x00\xd2\x18\x4e\x01\xbf\x04\xbd\x04\x80\x16\x45\x19\x00\x00\x00\x00\xbb\x04\xac\x04\x1f\x01\xd6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x03\x00\x00\x9c\x04\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x02\x00\x00\xfe\x07\xab\x18\xb4\x04\x00\x00\x00\x00\x45\x19\x97\x18\x45\x19\x45\x19\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x0e\x00\x00\x91\x04\x43\x0e\x00\x00\x7b\x05\x8f\x04\xf3\x13\x99\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x08\x95\x04\x89\x04\x00\x00\x00\x00\x00\x00\x8c\x04\x88\x04\xdb\x17\x00\x00\x45\x19\x6f\x0a\x82\x04\x0d\x0a\x00\x00\x00\x00\x6e\x04\x0a\x00\x00\x00\xa8\x19\x7a\x04\xae\x16\x00\x00\xdb\x17\x5c\x18\x23\x08\x75\x04\x00\x00\x12\x04\x59\x04\x00\x00\x4b\x04\x43\x0e\x00\x00\x45\x04\x00\x00\x45\x19\xd4\x17\x00\x00\x00\x00\x45\x19\x00\x00\x19\x01\xf4\x01\x00\x00\x00\x00\x00\x00\x42\x04\x84\x01\xf2\x02\x49\x04\x00\x00\x14\x01\x1d\x04\x00\x00\x86\x17\x00\x00\x6a\x05\x3e\x17\x00\x00\xe1\x0d\x00\x00\x00\x00\x00\x00\x2f\x04\x06\x04\x06\x04\x00\x00\x00\x00\x57\x01\x00\x00\x2c\x04\xc6\x03\xb0\x03\x86\x17\x00\x00\xf9\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x17\xcf\x00\x00\x00\x00\x00\x45\x19\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x0d\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\x01\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x08\x00\x00\x00\x06\x00\x00\x00\x58\x03\x4d\x03\x11\x04\x5a\x03\x7b\x04\x00\x00\x00\x00\x7f\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x46\x03\x36\x03\x03\x00\x00\x00\x00\x00\x00\x00\x78\x04\x00\x00\x00\x00\x00\x00\x51\x04\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x64\x03\xe6\x26\x00\x00\x00\x00\x07\x00\x00\x00\xbb\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\x98\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x03\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x20\x8e\x20\x00\x00\x9e\x27\x54\x21\x00\x00\x01\x20\xb5\x1f\xb6\x25\x3c\x03\x0f\x03\x51\x06\x15\x04\x32\x25\x00\x00\xa0\x03\xc4\x02\x00\x00\x33\x06\x00\x00\x88\x27\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x26\x69\x1f\x00\x00\xf0\x24\xba\x02\x00\x00\x00\x00\x00\x00\xaa\x00\xa4\x03\x00\x00\x00\x00\x00\x00\xaf\x02\x80\x00\x00\x00\x27\x04\x39\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x3c\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x01\x44\x03\x82\x03\x7d\x03\x1f\x04\x00\x00\x09\x1d\xbd\x1c\x00\x00\x00\x00\x3c\x04\x4c\x03\x00\x00\x00\x00\x4e\x03\xce\x02\x00\x00\x00\x00\xa5\x02\x3b\x00\x9a\x02\x06\x03\x00\x00\x00\x00\x00\x00\xab\x0f\x00\x00\xab\x02\xae\x24\x2a\x00\x01\x03\xf7\x02\x00\x00\x00\x00\x88\x27\x4d\x27\x37\x27\x00\x00\xb9\x02\xc2\xff\x00\x00\x00\x00\x00\x00\x09\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x04\x00\x00\x00\x00\x1d\x1f\x00\x00\x00\x00\x00\x00\x72\x01\x90\x02\x2e\x02\x85\x02\xf8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x02\x00\x00\x00\x00\x00\x00\x83\x04\x27\x00\x00\x00\x00\x00\x1f\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x04\x00\x00\x1f\x26\x00\x00\x00\x00\xdb\x03\x9b\x02\x00\x00\xfc\x26\x1b\x02\x00\x00\x00\x00\xda\x00\x00\x00\xfb\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x24\x00\x00\x00\x00\x00\x00\x2a\x24\x12\x21\xe8\x23\x00\x00\xa6\x23\x64\x23\xf5\x1a\x22\x23\x00\x00\xa9\x1a\x00\x00\x00\x00\xbd\x16\x00\x00\x00\x00\x50\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x01\xd9\x01\xa2\x02\x00\x00\xef\x03\xe8\xff\x00\x00\x00\x00\x43\x02\x00\x00\x00\x00\x5d\x1a\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\xb6\x02\x00\x00\x00\x00\xf8\xff\x00\x00\x00\x00\x6c\x00\x59\x00\x00\x00\x5a\x26\xbd\x16\x1f\x02\xc8\xff\x65\x02\x40\x03\x7e\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x02\xd8\xff\x1a\x04\x78\x03\x00\x00\x03\x02\x00\x00\xbe\x03\x00\x00\xa1\x03\x00\x00\x00\x00\xe7\x01\x99\x03\x65\x04\x00\x00\x95\x06\xef\x01\x00\x00\x71\x1c\xf7\xff\xd1\x01\x00\x00\xf7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x04\x7b\x02\x00\x00\x7c\x04\x00\x00\x00\x00\xb9\x03\x00\x00\x63\x03\x00\x00\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x1c\x7c\x04\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x01\x07\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x01\x66\x02\x37\x03\xd5\x01\x5e\x03\x00\x00\x00\x00\x93\x01\x00\x00\x00\x00\x00\x00\xd9\xff\x00\x00\x78\x00\x4e\x00\xee\x01\x00\x00\x70\x26\x00\x00\x00\x00\xe0\x22\x15\x00\x00\x00\x00\x00\x6a\x01\x49\x01\x9e\x22\x00\x00\x00\x00\x00\x00\xed\x01\x2b\x01\xea\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x01\xf2\xff\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x01\x00\x00\x00\x00\x9a\x03\x00\x00\x00\x00\x1b\x00\x00\x00\x5a\x02\x68\x01\x00\x00\x00\x00\x00\x00\x2b\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x26\x00\x00\x00\x00\x00\x00\x6b\x03\xd0\x20\x5c\x22\x00\x00\x45\x02\x00\x00\x00\x00\x00\x00\x0b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x22\xd9\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x18\x01\x2f\x00\x00\x00\x86\x03\x44\x04\x9f\x00\x23\x00\x00\x00\x00\x00\x00\x00\xd1\x1e\x00\x00\x00\x00\x00\x00\x94\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x03\x00\x00\xc4\x03\x00\x00\xf6\x00\x00\x00\x00\x00\xd8\x21\x00\x00\x0e\x00\x00\x00\xed\x00\x00\x00\x05\x01\xc2\x00\xa6\x01\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x00\x00\xcd\x00\x00\x00\x00\x00\x85\x1e\x8d\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x03\x00\x00\x00\x00\x00\x00\x88\x00\x49\x03\x1c\x00\x93\x01\x00\x00\xf4\xff\x00\x00\x89\x00\x00\x00\x00\x00\x6e\x03\x00\x00\xcc\x25\x00\x00\x96\x21\x00\x00\xb9\x00\x00\x00\x40\x00\x00\x00\x00\x00\x8f\x03\x00\x00\x00\x00\x39\x1e\x00\x00\xd8\xff\x7c\x04\x00\x00\x00\x00\x00\x00\x6a\x04\xe4\x00\x00\x00\x00\x00\x83\x01\x77\x04\x00\x00\x00\x00\x24\x00\x00\x00\xd3\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\xca\x01\x00\x00\x00\x00\x2e\x03\x00\x00\x35\x01\x00\x00\xc5\x01\xb1\x00\x2e\x00\x00\x00\x00\x00\x72\x04\x4a\x04\xc3\x03\xfd\x03\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x00\x00\xc0\x01\xed\x1d\x00\x00\xd1\x05\xbf\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x02\x00\x00\x00\x00\xe0\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x01\x00\x00\x87\x03\xa2\x00\x00\x00\x41\x1b\x00\x00\x00\x00\x00\x00\x27\x01\x00\x00\x43\x00\x00\x00\xf3\xff\x00\x00\xd0\x01\x59\x03\x28\x00\x00\x00\x00\x00\x6a\x00\x54\x00\x00\x00\x00\x00\xa1\x1d\x00\x00\x00\x00\x00\x00\x74\x01\x74\x01\x00\x00\x00\x00\x74\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\xde\xff\x00\x00\x00\x00\x37\x01\x00\x00\x00\x00\xb8\x01\x00\x00\x39\x03\x98\x01\x00\x00\x11\x1a\x00\x00\x00\x00\x00\x00\x00\x00\xee\xff\xd4\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\xad\x01\x00\x00\xda\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x01\x00\x00\x00\x00\x00\x00\x56\x01\x00\x00\x00\x00\x00\x00\x00\x00\x55\x1d\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\x57\xfe\x00\x00\xfe\xff\x00\x00\x00\x00\xfc\xff\x56\xfe\x57\xfe\x00\x00\x56\xfe\xf8\xff\xef\xff\xef\xff\x00\x00\x00\x00\xed\xff\x53\xfe\x52\xfe\xcd\xfe\xd4\xfe\xd3\xfe\xd2\xfe\xd1\xfe\xcf\xfe\xd0\xfe\x00\x00\xf0\xff\xf2\xff\x00\x00\x57\xfe\x57\xfe\xf6\xff\x54\xfe\x55\xfe\xef\xff\xdf\xff\xa3\xff\xf4\xff\xef\xff\xbe\xff\xae\xff\xa4\xff\xa2\xff\x57\xfe\xf1\xff\xf7\xff\x00\x00\x57\xfe\x00\x00\xee\xff\xe9\xff\x00\x00\xe9\xff\xe7\xff\xe6\xff\x97\xfe\x75\xfe\x7e\xfe\x50\xfe\x6f\xfe\xe5\xff\x7c\xfe\x7d\xfe\x6d\xfe\x6e\xfe\x00\x00\xea\xff\x78\xfe\x74\xfe\x73\xfe\x72\xfe\x77\xfe\x76\xfe\x7b\xfe\x79\xfe\x00\x00\x7a\xfe\x56\xfe\xcb\xfe\x00\xff\xfd\xfe\xf0\xfe\x00\x00\xce\xfe\x00\x00\xfa\xfe\xfb\xfe\xfc\xfe\x9c\xfe\x95\xfe\x92\xfe\xf9\xfe\x00\x00\x7c\xfe\x71\xfe\x70\xfe\x6d\xfe\x5b\xfe\x59\xfe\x5a\xfe\x58\xfe\x57\xfe\x57\xfe\xf4\xfe\x57\xfe\x57\xfe\xef\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x56\xfe\x00\x00\x00\x00\x57\xfe\xd5\xfe\xc7\xff\x00\x00\x00\x00\x57\xfe\x11\xff\x09\xff\x07\xff\x12\xff\xfb\xfe\xc9\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\xad\xff\x00\x00\x00\x00\x56\xfe\xdc\xff\xc5\xff\xc4\xff\xc3\xff\x00\x00\x56\xfe\xac\xff\x00\x00\xf0\xff\xc0\xff\xf0\xff\xf3\xff\xfd\xff\xe0\xff\xf5\xff\xbf\xff\x57\xfe\x00\x00\x91\xff\x89\xff\x88\xff\x4e\xfe\x81\xff\x87\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\xff\x57\xfe\x57\xfe\x8b\xff\x79\xff\x91\xff\x2d\xff\x00\x00\x00\x00\x72\xff\x00\x00\xdd\xff\x0b\xff\x00\x00\xa9\xff\x00\x00\x6d\xff\x00\x00\x19\xff\x17\xff\x16\xff\x14\xff\x57\xfe\x57\xfe\x56\xfe\x00\x00\x00\x00\x00\x00\x1b\xff\x0c\xff\x57\xfe\x57\xfe\x08\xff\x21\xff\x1f\xff\x1d\xff\x84\xfe\x83\xfe\x57\xfe\x88\xfe\x7f\xfe\x6c\xfe\x8e\xfe\x69\xfe\x68\xfe\x00\x00\x65\xfe\x6a\xfe\x5c\xfe\x6b\xfe\x00\x00\x62\xfe\x80\xfe\x57\xfe\x64\xfe\x63\xfe\x61\xfe\x00\x00\x00\x00\x62\xff\x00\x00\x00\x00\xc6\xff\x00\x00\xe6\xfe\xe7\xfe\x00\x00\x00\x00\xe9\xfe\xe8\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x16\xff\x00\x00\x00\x00\xe0\xfe\x00\x00\x01\xff\xc8\xfe\x00\x00\xc7\xfe\x9e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x82\xfe\x81\xfe\x57\xfe\x88\xfe\x00\x00\x8c\xfe\x67\xfe\x66\xfe\x60\xfe\x9f\xfe\xe4\xfe\x00\x00\x5e\xfe\x64\xfe\x5f\xfe\x5d\xfe\x00\x00\xd9\xfe\xfa\xff\x57\xfe\x00\x00\xf9\xff\xe1\xff\x00\x00\x00\x00\xea\xff\xeb\xff\xe8\xff\xec\xff\x00\x00\xcb\xff\xca\xff\xc9\xff\x9b\xfe\x94\xfe\x00\x00\xe3\xff\x00\x00\x00\x00\xa5\xfe\x00\x00\xff\xfe\xcc\xfe\x57\xfe\xcd\xfe\x00\x00\x00\x00\x96\xfe\x91\xfe\x00\x00\xf3\xfe\xf7\xfe\x57\xfe\x9d\xfe\xe5\xfe\xf8\xfe\x57\xfe\x57\xfe\x57\xfe\xf6\xfe\x57\xfe\xc6\xfe\x57\xfe\x57\xfe\xf2\xfe\x57\xfe\xee\xfe\xed\xfe\x57\xfe\xec\xfe\xeb\xfe\x00\x00\x00\x00\x7e\xff\x00\x00\x80\xff\x00\x00\xdb\xfe\xc8\xff\x86\xfe\x85\xfe\xc1\xff\x8a\xfe\x90\xfe\x00\x00\x62\xff\x49\xff\x00\x00\x00\x00\x57\xfe\x9f\xff\x9b\xff\x00\x00\x20\xff\x00\x00\x57\xfe\x13\xff\x1e\xff\x23\xff\x56\xfe\x02\xff\x03\xff\xb1\xff\x94\xff\x99\xff\x98\xff\x00\x00\x9e\xff\x00\x00\xef\xff\xef\xff\x00\x00\x57\xfe\x18\xff\x57\xfe\x56\xfe\x3b\xff\x6e\xff\x3e\xff\x00\x00\xaa\xff\xab\xff\x00\x00\xb3\xff\xda\xff\x00\x00\x00\x00\x00\x00\xb4\xff\x56\xfe\x8a\xff\x00\x00\x7c\xff\x00\x00\x4c\xfe\x4b\xfe\x00\x00\x00\x00\x00\x00\xa7\xfe\x16\xff\x57\xfe\x00\x00\x57\xfe\x56\xfe\x00\x00\x00\x00\x3e\xff\x00\x00\x75\xff\x00\x00\x79\xff\x00\x00\x00\x00\x00\x00\x00\x00\xbd\xff\x8d\xff\x86\xff\x83\xff\x00\x00\x85\xff\x00\x00\x84\xff\xbc\xff\x00\x00\xad\xfe\x00\x00\xa9\xfe\xae\xfe\x00\x00\xa8\xfe\x8d\xff\x8e\xff\x00\x00\x8f\xff\x90\xff\xef\xff\xef\xff\x7a\xff\x8c\xff\x73\xff\x71\xff\x00\x00\x00\x00\xd8\xff\x00\x00\x00\x00\xb2\xff\xb8\xff\x00\x00\x6c\xff\x6a\xff\xb5\xff\x56\xfe\x0d\xff\xef\xff\xef\xff\x00\x00\x15\xff\x57\xfe\x05\xff\x04\xff\x57\xfe\xa7\xff\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\xaf\xff\x00\x00\x99\xfe\x00\x00\x00\x00\x00\x00\x97\xff\x96\xff\x95\xff\x22\xff\xbc\xfe\x00\x00\xbe\xfe\x57\xfe\x56\xfe\x8d\xfe\x00\x00\x61\xff\x5f\xff\x5b\xff\x3d\xff\x43\xff\x00\x00\x40\xff\x41\xff\x56\xfe\xba\xff\x00\x00\x49\xff\x00\x00\x00\x00\x00\x00\x00\x00\x7f\xff\x7d\xff\x00\x00\x00\x00\xe1\xfe\xc2\xfe\xc4\xfe\xc0\xfe\xc1\xfe\xde\xfe\xdf\xfe\xe2\xfe\xe3\xfe\xf5\xfe\x87\xfe\x8b\xfe\x57\xfe\xd6\xfe\xda\xfe\xd8\xfe\x00\x00\x57\xfe\x57\xfe\xfe\xfe\x00\x00\xe4\xff\x00\x00\xe2\xff\x00\x00\xcc\xff\x93\xfe\xa6\xfe\xa4\xfe\xe0\xfe\x00\x00\x00\x00\x00\x00\xc5\xfe\x57\xfe\xf1\xfe\xea\xfe\xc2\xff\x89\xfe\x8f\xfe\x56\xfe\xb7\xff\x4f\xfe\x48\xff\x00\x00\xb9\xff\xef\xff\xef\xff\x00\x00\x00\x00\x00\x00\x72\xff\x57\xfe\x9a\xfe\xbb\xfe\x00\x00\x57\xfe\xb0\xff\x00\x00\x00\x00\x00\x00\x0f\xff\x9c\xff\xa0\xff\x9d\xff\xa1\xff\xef\xff\xa5\xff\xef\xff\xa1\xfe\x57\xfe\x00\x00\x06\xff\x57\xfe\x1a\xff\x57\xfe\x00\x00\x00\x00\x3c\xff\xef\xff\xef\xff\x6e\xff\x6f\xff\x6e\xff\x76\xff\xdb\xff\xde\xff\xd9\xff\x00\x00\xd5\xff\x7b\xff\x00\x00\x2b\xff\x00\x00\x00\x00\x4d\xfe\xaa\xfe\x57\xfe\x57\xfe\xbb\xff\x74\xff\x00\x00\x82\xff\xac\xfe\x00\x00\x2e\xff\x2f\xff\xef\xff\x29\xff\x27\xff\x28\xff\x57\xfe\x00\x00\xe9\xff\x69\xff\x6b\xff\x37\xff\x00\x00\x00\x00\xb9\xfe\xba\xfe\xef\xff\xb6\xfe\x57\xfe\x10\xff\x57\xfe\xfc\xfe\xf0\xff\xa3\xfe\xf0\xff\xa8\xff\x92\xff\x00\x00\x98\xfe\x1c\xff\x57\xfe\x60\xff\x00\x00\x56\xff\x00\x00\x5d\xff\x5a\xff\x55\xff\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x42\xff\x3f\xff\x57\xfe\x00\x00\x00\x00\x00\x00\x44\xff\x47\xff\xb6\xff\xbf\xfe\xc3\xfe\xd9\xfe\xdc\xfe\xfb\xff\xd7\xfe\x57\xfe\x46\xff\x00\x00\x67\xff\x68\xff\xef\xff\x64\xff\x00\x00\x4f\xff\x00\x00\x00\x00\x00\x00\x52\xff\x53\xff\x00\x00\x00\x00\x00\x00\x00\x00\x5c\xff\xbd\xfe\x93\xff\xa6\xff\x57\xfe\xa2\xfe\x00\x00\x57\xfe\x0e\xff\xaf\xfe\x57\xfe\xf0\xff\xb8\xfe\x39\xff\x3a\xff\x34\xff\xef\xff\x35\xff\x33\xff\x57\xfe\x00\x00\xe9\xff\xd2\xff\xd1\xff\x51\xfe\xd0\xff\x00\x00\x00\x00\xad\xff\x00\x00\xf0\xff\x2c\xff\x57\xfe\xab\xfe\x2a\xff\x00\x00\x62\xff\x70\xff\x00\x00\x00\x00\xea\xff\xd6\xff\x00\x00\x00\x00\xf0\xff\x38\xff\xb7\xfe\x21\xff\xb3\xfe\xb1\xfe\x00\x00\x57\xfe\xa0\xfe\x00\x00\x54\xff\x77\xff\x56\xff\x5e\xff\x51\xff\x50\xff\x59\xff\x00\x00\x00\x00\x4d\xff\x9a\xff\x58\xff\x00\x00\x00\x00\xf0\xff\x66\xff\x45\xff\x00\x00\x00\x00\x65\xff\x00\x00\x57\xff\x00\x00\x00\x00\xb4\xfe\x57\xfe\xb2\xfe\xb5\xfe\x36\xff\x8b\xff\x3e\xff\x3e\xff\xd3\xff\xd7\xff\x00\x00\xce\xff\x00\x00\x49\xff\x00\x00\x00\x00\x26\xff\x56\xfe\x25\xff\xcf\xff\xcd\xff\x30\xff\x32\xff\x00\x00\x00\x00\x4b\xff\x4c\xff\x00\x00\x4e\xff\x63\xff\xdd\xfe\x4a\xff\x57\xfe\x31\xff\x24\xff\xb0\xfe"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x00\x00\x01\x00\x02\x00\x01\x00\x01\x00\x0b\x00\x14\x00\x03\x00\x03\x00\x02\x00\x17\x00\x03\x00\x35\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x29\x00\x3a\x00\x23\x00\x22\x00\x25\x00\x24\x00\x17\x00\x23\x00\x3d\x00\x25\x00\x1b\x00\x1c\x00\x1d\x00\x5e\x00\x29\x00\x4e\x00\x0d\x00\x22\x00\x09\x00\x24\x00\x3f\x00\x40\x00\x50\x00\x20\x00\x21\x00\x17\x00\x17\x00\x42\x00\x13\x00\x14\x00\x1b\x00\x1c\x00\x1d\x00\x05\x00\x06\x00\x21\x00\x22\x00\x22\x00\x24\x00\x24\x00\x23\x00\x4e\x00\x25\x00\x17\x00\x17\x00\x54\x00\x10\x00\x1b\x00\x1c\x00\x1d\x00\x7d\x00\x52\x00\x53\x00\x54\x00\x22\x00\x22\x00\x24\x00\x24\x00\x23\x00\x5a\x00\x25\x00\x17\x00\x3a\x00\x09\x00\x05\x00\x06\x00\x3a\x00\x1d\x00\x17\x00\x15\x00\x16\x00\x1f\x00\x22\x00\x5a\x00\x24\x00\x05\x00\x06\x00\x3c\x00\x3d\x00\x22\x00\x40\x00\x24\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x3b\x00\x61\x00\xaa\x00\x32\x00\x33\x00\x5a\x00\x5a\x00\x05\x00\x06\x00\xab\x00\x14\x00\x9d\x00\x9e\x00\x15\x00\x8e\x00\x20\x00\x4a\x00\x53\x00\x54\x00\x05\x00\x06\x00\xac\x00\x8d\x00\x5a\x00\x5a\x00\x52\x00\xab\x00\xab\x00\x8e\x00\x9d\x00\xaa\x00\xb1\x00\x8f\x00\x71\x00\x20\x00\x7f\x00\x80\x00\x15\x00\x9d\x00\x9e\x00\xaa\x00\x5a\x00\xa1\x00\x9d\x00\x8f\x00\x9c\x00\x9d\x00\x9e\x00\x5a\x00\xa0\x00\xa1\x00\xab\x00\xaa\x00\x8a\x00\x8b\x00\xae\x00\xab\x00\x9c\x00\x9d\x00\x9e\x00\x1e\x00\xa0\x00\xa1\x00\x8d\x00\xaf\x00\xaa\x00\xaa\x00\xaa\x00\xaa\x00\x36\x00\xab\x00\xab\x00\xaa\x00\x39\x00\xab\x00\x55\x00\xaf\x00\x19\x00\xaa\x00\x9d\x00\x9e\x00\x4b\x00\x1e\x00\xa1\x00\x5c\x00\xaa\x00\xaa\x00\x26\x00\xab\x00\xab\x00\x26\x00\x5b\x00\xab\x00\x05\x00\x06\x00\x2e\x00\xae\x00\x90\x00\x7e\x00\xaa\x00\xaa\x00\xa1\x00\x8d\x00\xaa\x00\xaa\x00\x34\x00\x91\x00\xab\x00\x5c\x00\x83\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2c\x00\x2d\x00\x2e\x00\x9d\x00\x9e\x00\x89\x00\xaa\x00\xa1\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x1a\x00\xaa\x00\x63\x00\xb1\x00\x65\x00\x66\x00\x15\x00\x16\x00\x69\x00\x6a\x00\x6b\x00\x25\x00\x89\x00\x7e\x00\x46\x00\x70\x00\x19\x00\x58\x00\x59\x00\x5a\x00\x70\x00\xaa\x00\x72\x00\x78\x00\x63\x00\x80\x00\x65\x00\x66\x00\x85\x00\x26\x00\x69\x00\x6a\x00\x6b\x00\x05\x00\x06\x00\x05\x00\x06\x00\x70\x00\x19\x00\xa0\x00\xa1\x00\x1a\x00\x51\x00\x8c\x00\x01\x00\x78\x00\x8f\x00\x90\x00\x05\x00\x92\x00\x07\x00\x26\x00\x05\x00\x06\x00\x00\x00\xb0\x00\x16\x00\x05\x00\x06\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xab\x00\xaa\x00\x8f\x00\x90\x00\x85\x00\x92\x00\xa9\x00\xaa\x00\x1a\x00\x1a\x00\xac\x00\x17\x00\xaa\x00\xaa\x00\x20\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x81\x00\x82\x00\x83\x00\x63\x00\x8b\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xaa\x00\x1a\x00\x9d\x00\x9e\x00\x70\x00\xa0\x00\xa1\x00\x3b\x00\x21\x00\xab\x00\x51\x00\x09\x00\x78\x00\x63\x00\x40\x00\x65\x00\x66\x00\x56\x00\x4a\x00\x69\x00\x6a\x00\x6b\x00\xb1\x00\xaa\x00\x11\x00\x3e\x00\x70\x00\x8d\x00\x11\x00\xaa\x00\x1c\x00\x91\x00\x8c\x00\x1a\x00\x78\x00\x8f\x00\x90\x00\x1a\x00\x92\x00\x56\x00\x60\x00\x4e\x00\x23\x00\x9d\x00\x9e\x00\xac\x00\x96\x00\xa1\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\x2d\x00\x2e\x00\x8f\x00\x90\x00\xa3\x00\x92\x00\xa9\x00\xaa\x00\x93\x00\x10\x00\x09\x00\x96\x00\x0b\x00\x98\x00\x11\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8d\x00\xac\x00\x1a\x00\xa3\x00\x91\x00\x13\x00\xa6\x00\xa9\x00\xaa\x00\x2d\x00\x2e\x00\x1f\x00\x1a\x00\x25\x00\x2a\x00\x2b\x00\x9d\x00\x9e\x00\x73\x00\x74\x00\xa1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x4a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x41\x00\x30\x00\x31\x00\x32\x00\x33\x00\x1a\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x92\x00\x30\x00\x31\x00\xaa\x00\x08\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xa6\x00\x30\x00\x31\x00\x2d\x00\xa0\x00\xa1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x36\x00\x30\x00\x31\x00\x39\x00\x1d\x00\x49\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\x30\x00\x31\x00\x9b\x00\x26\x00\x29\x00\x2a\x00\x2b\x00\x6c\x00\x1a\x00\xa2\x00\xa3\x00\x9d\x00\x9e\x00\xac\x00\xa0\x00\xa1\x00\x1a\x00\x6c\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x8d\x00\x30\x00\x31\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xb1\x00\x30\x00\x31\x00\x16\x00\x2d\x00\x47\x00\x48\x00\x1a\x00\x9d\x00\x9e\x00\x9d\x00\x9e\x00\x90\x00\xa0\x00\xa1\x00\xac\x00\x3e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x90\x00\x30\x00\x31\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xb1\x00\xa3\x00\x4e\x00\x90\x00\x1a\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x20\x00\x9d\x00\x9e\x00\x90\x00\x11\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x08\x00\x09\x00\x1a\x00\x90\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xb1\x00\x4e\x00\x9d\x00\x9e\x00\x90\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x1d\x00\x90\x00\x08\x00\x09\x00\xb1\x00\x8f\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xb1\x00\x29\x00\x2a\x00\x2b\x00\xb1\x00\x9f\x00\x90\x00\x9c\x00\x9d\x00\x9e\x00\xa3\x00\x1c\x00\x1d\x00\xa6\x00\x90\x00\xb1\x00\xa0\x00\xa1\x00\x3e\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x29\x00\x2a\x00\x2b\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xb0\x00\x8e\x00\x4e\x00\xac\x00\x90\x00\x9d\x00\x9e\x00\xb1\x00\xad\x00\xa1\x00\x9d\x00\x9e\x00\x11\x00\xa0\x00\xa1\x00\xb1\x00\x9d\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x20\x00\x30\x00\x31\x00\xb1\x00\xaa\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xb1\x00\x30\x00\x31\x00\x87\x00\x88\x00\x11\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x8f\x00\x30\x00\x31\x00\x1a\x00\xab\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x4f\x00\x30\x00\x31\x00\x9c\x00\x9d\x00\x9e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x0f\x00\x30\x00\x31\x00\x05\x00\x06\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xaa\x00\x30\x00\x31\x00\x4e\x00\x88\x00\x11\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x8f\x00\x30\x00\x31\x00\x05\x00\x06\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x28\x00\x30\x00\x31\x00\x9c\x00\x9d\x00\x9e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xa6\x00\x30\x00\x31\x00\x4a\x00\x1a\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x20\x00\x30\x00\x31\x00\x90\x00\x05\x00\x06\x00\x26\x00\xa0\x00\xa1\x00\xac\x00\x05\x00\x06\x00\x75\x00\x90\x00\x2e\x00\x10\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x10\x00\x6c\x00\xb0\x00\x90\x00\x71\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x05\x00\x06\x00\x5b\x00\x90\x00\x11\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x10\x00\x27\x00\x1a\x00\x90\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x16\x00\x27\x00\x11\x00\x90\x00\x1a\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x1a\x00\x05\x00\x06\x00\x90\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa4\x00\x37\x00\xa6\x00\x90\x00\xa8\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x10\x00\x11\x00\x12\x00\x90\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x04\x00\x05\x00\x06\x00\x90\x00\xaa\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x04\x00\x05\x00\x06\x00\x26\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xb1\x00\x30\x00\x31\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x05\x00\x06\x00\xb1\x00\x36\x00\x33\x00\x38\x00\x39\x00\x1f\x00\xad\x00\x21\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x48\x00\x34\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x1d\x00\x1a\x00\x1f\x00\x4c\x00\x4d\x00\x1e\x00\x43\x00\x44\x00\x45\x00\x1f\x00\x23\x00\x21\x00\x29\x00\x2a\x00\x2b\x00\x55\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2a\x00\x0e\x00\x2c\x00\x2d\x00\x2e\x00\x05\x00\x06\x00\x18\x00\x2a\x00\xab\x00\x2c\x00\x2d\x00\x2e\x00\x2a\x00\xad\x00\x2c\x00\x2d\x00\x2e\x00\x2a\x00\x09\x00\x2c\x00\x2d\x00\x2e\x00\x8f\x00\x05\x00\x06\x00\x2a\x00\x90\x00\x2c\x00\x2d\x00\x2e\x00\x05\x00\x06\x00\x4c\x00\x4d\x00\x90\x00\x9c\x00\x9d\x00\x9e\x00\x74\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x73\x00\x74\x00\xaa\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x4c\x00\x4d\x00\x2a\x00\x90\x00\x2c\x00\x2d\x00\x2e\x00\xb1\x00\x90\x00\x2c\x00\x2d\x00\x2e\x00\xac\x00\x90\x00\x75\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x4c\x00\x4d\x00\xad\x00\x90\x00\x38\x00\xb1\x00\x3a\x00\x3b\x00\x90\x00\x15\x00\xb1\x00\x3f\x00\x61\x00\x90\x00\x4d\x00\xb1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x20\x00\xa0\x00\xa1\x00\xb1\x00\x2d\x00\x2e\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x4c\x00\x4d\x00\x11\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x2e\x00\x2a\x00\xb1\x00\x2c\x00\x2d\x00\x2e\x00\x2a\x00\xb1\x00\x2c\x00\x2d\x00\x2e\x00\x73\x00\x74\x00\x21\x00\x2a\x00\xb1\x00\x2c\x00\x2d\x00\x2e\x00\x05\x00\x06\x00\x08\x00\x3c\x00\x0a\x00\x9d\x00\x9e\x00\x14\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x20\x00\xa0\x00\xa1\x00\x38\x00\x21\x00\x3a\x00\x3b\x00\x2d\x00\x2e\x00\x2f\x00\x3f\x00\x1d\x00\x23\x00\xb1\x00\x2c\x00\x2d\x00\x2e\x00\x61\x00\xb1\x00\x31\x00\x2c\x00\x2d\x00\x2e\x00\x29\x00\x2a\x00\x2b\x00\x23\x00\x05\x00\x06\x00\x2c\x00\x2d\x00\x2e\x00\x07\x00\x08\x00\x73\x00\x74\x00\x42\x00\x43\x00\x44\x00\x14\x00\x46\x00\x11\x00\x42\x00\x43\x00\x44\x00\x21\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x03\x00\x04\x00\x14\x00\x2d\x00\x2e\x00\x11\x00\x9d\x00\x9e\x00\x10\x00\xa0\x00\xa1\x00\x2d\x00\x2e\x00\x05\x00\x06\x00\x1a\x00\x2d\x00\x2e\x00\x11\x00\x03\x00\x04\x00\x2d\x00\x2e\x00\x3c\x00\x3d\x00\x14\x00\xb1\x00\x45\x00\x05\x00\x06\x00\x9d\x00\x9e\x00\x25\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x05\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x93\x00\xa0\x00\xa1\x00\x96\x00\x16\x00\x98\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x05\x00\x06\x00\xb1\x00\x46\x00\x47\x00\xa3\x00\x14\x00\xb1\x00\xa6\x00\x15\x00\x97\x00\x15\x00\x91\x00\x28\x00\x9b\x00\xb1\x00\x9d\x00\x9e\x00\x91\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\x14\x00\x9d\x00\x9e\x00\x21\x00\xa0\x00\xa1\x00\x16\x00\x9d\x00\x9e\x00\x14\x00\xa0\x00\xa1\x00\x11\x00\xb1\x00\xb2\x00\xb3\x00\x9d\x00\x9e\x00\x16\x00\xa0\x00\xa1\x00\xb1\x00\x3c\x00\x3d\x00\x9c\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x05\x00\x06\x00\x20\x00\x10\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\x1a\x00\xa0\x00\xa1\x00\x16\x00\x4f\x00\x14\x00\x9d\x00\x9e\x00\x11\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x9d\x00\x9e\x00\xb1\x00\xa0\x00\xa1\x00\x9b\x00\x20\x00\x24\x00\x11\x00\x55\x00\xb1\x00\x15\x00\xa2\x00\xa3\x00\xa4\x00\xb1\x00\xa6\x00\x3c\x00\xa8\x00\x11\x00\xb1\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\x9c\x00\x9d\x00\x9e\x00\x23\x00\xa0\x00\xa1\x00\x18\x00\x1e\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1a\x00\x1f\x00\x35\x00\x1c\x00\x22\x00\x1c\x00\x61\x00\x4d\x00\x15\x00\x27\x00\x25\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x51\x00\x23\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x11\x00\x36\x00\x37\x00\x15\x00\x20\x00\x15\x00\x3b\x00\x16\x00\x16\x00\x01\x00\x02\x00\x24\x00\x19\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x1a\x00\x1c\x00\x11\x00\x10\x00\x4e\x00\x1a\x00\x16\x00\x20\x00\x52\x00\x53\x00\x21\x00\x15\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x5a\x00\x5b\x00\x14\x00\x48\x00\x15\x00\x1a\x00\x1a\x00\x11\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x1c\x00\x1d\x00\x20\x00\x1f\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x61\x00\x15\x00\x5f\x00\x14\x00\x29\x00\x2a\x00\x2b\x00\x18\x00\x15\x00\x1c\x00\x1b\x00\x55\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x4d\x00\x1a\x00\x11\x00\x27\x00\x11\x00\x29\x00\x61\x00\x11\x00\x2c\x00\x52\x00\x1c\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x1c\x00\x36\x00\x37\x00\x11\x00\x39\x00\x11\x00\x3b\x00\x21\x00\x62\x00\x01\x00\x11\x00\x11\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x11\x00\x11\x00\x11\x00\x52\x00\x1a\x00\x54\x00\x11\x00\x56\x00\x57\x00\x58\x00\x59\x00\x11\x00\x5b\x00\x11\x00\x5d\x00\x19\x00\x23\x00\x60\x00\x11\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x35\x00\x35\x00\x35\x00\x19\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x15\x00\x23\x00\x23\x00\x3e\x00\x61\x00\x11\x00\x23\x00\x18\x00\x5e\x00\x20\x00\x1b\x00\x21\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x61\x00\x28\x00\x14\x00\x27\x00\x15\x00\x29\x00\x62\x00\x15\x00\x2c\x00\x52\x00\x10\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x50\x00\x36\x00\x37\x00\x59\x00\x39\x00\x0c\x00\x3b\x00\x39\x00\x62\x00\x21\x00\x15\x00\x15\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x10\x00\x1a\x00\x11\x00\x52\x00\x16\x00\x54\x00\x10\x00\x56\x00\x57\x00\x58\x00\x59\x00\x61\x00\x5b\x00\x39\x00\x5d\x00\x3e\x00\x3b\x00\x60\x00\x63\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\x94\x00\xff\xff\xff\xff\x97\x00\xff\xff\x99\x00\x18\x00\x9b\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xa4\x00\xff\xff\xa6\x00\xff\xff\xa8\x00\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\x94\x00\xff\xff\xff\xff\x97\x00\xff\xff\x99\x00\x18\x00\x9b\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xa4\x00\xff\xff\xa6\x00\xff\xff\xa8\x00\x27\x00\xaa\x00\x29\x00\xff\xff\x8f\x00\x2c\x00\xff\xff\x92\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\x9c\x00\x9d\x00\x9e\x00\x3b\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\x54\x00\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\x94\x00\xff\xff\xff\xff\x97\x00\xff\xff\x99\x00\x18\x00\x9b\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xa4\x00\xff\xff\xa6\x00\xff\xff\xa8\x00\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\x62\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\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\x21\x00\xff\xff\x23\x00\x01\x00\xff\xff\xff\xff\x27\x00\x05\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\x52\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\x01\x00\x02\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x16\x00\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\x01\x00\x02\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x16\x00\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\x62\x00\x01\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\x1d\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\x01\x00\x02\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\x01\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1d\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\x0f\x00\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x10\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\x42\x00\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x94\x00\x4b\x00\xff\xff\x97\x00\x4e\x00\x99\x00\xff\xff\x9b\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xa4\x00\x5b\x00\xa6\x00\x5d\x00\xa8\x00\xff\xff\x60\x00\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\x94\x00\xff\xff\xff\xff\x97\x00\xff\xff\x99\x00\x18\x00\x9b\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xa4\x00\xff\xff\xa6\x00\xff\xff\xa8\x00\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\x1c\x00\x1d\x00\x52\x00\x1f\x00\x20\x00\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\x1c\x00\x1d\x00\x52\x00\x1f\x00\x20\x00\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\x5b\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\x1c\x00\x1d\x00\x52\x00\x1f\x00\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x4a\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\x62\x00\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\x01\x00\x02\x00\xff\xff\x3b\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\xff\xff\x52\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x27\x00\x05\x00\x06\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\x39\x00\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\x1b\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\x52\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x01\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\x52\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\xff\xff\x1c\x00\x25\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\xff\xff\x27\x00\x28\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\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x52\x00\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\x52\x00\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x10\x00\x11\x00\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x18\x00\x01\x00\x1a\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\x25\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x18\x00\xff\xff\xff\xff\x05\x00\x1c\x00\xff\xff\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\x10\x00\x27\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x52\x00\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x62\x00\x10\x00\x11\x00\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x18\x00\xff\xff\x1a\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x25\x00\xff\xff\x62\x00\x05\x00\x06\x00\xff\xff\xff\xff\x09\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\xff\xff\x1c\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x64\x00\x65\x00\x66\x00\x51\x00\x52\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x52\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\x10\x00\x92\x00\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xa9\x00\xaa\x00\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x51\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x51\x00\x52\x00\x05\x00\x06\x00\xff\xff\x01\x00\x09\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\x62\x00\xff\xff\xff\xff\x10\x00\x18\x00\x12\x00\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x2a\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\x52\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x51\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x62\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x01\x00\x62\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x18\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x52\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x62\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\x01\x00\xff\xff\x52\x00\x18\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x62\x00\xff\xff\x01\x00\x2a\x00\xff\xff\x18\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x2a\x00\xff\xff\x05\x00\x06\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\x01\x00\xff\xff\x52\x00\x18\x00\x05\x00\x06\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x62\x00\xff\xff\x01\x00\x2a\x00\x52\x00\x18\x00\x05\x00\x06\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x62\x00\xff\xff\xff\xff\x2a\x00\x52\x00\x18\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x28\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\xff\xff\x52\x00\x05\x00\x06\x00\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x10\x00\xff\xff\x01\x00\xff\xff\x62\x00\xff\xff\x05\x00\x06\x00\x52\x00\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\x01\x00\x02\x00\x62\x00\x18\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x62\x00\x52\x00\xff\xff\x05\x00\x06\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x62\x00\xff\xff\x01\x00\xff\xff\x52\x00\x18\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x52\x00\xff\xff\x05\x00\x06\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x52\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x02\x00\x62\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x62\x00\x05\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x62\x00\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\xff\xff\x6f\x00\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\xff\xff\x97\x00\xff\xff\xff\xff\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x79\x00\x7a\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xa9\x00\xaa\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\x78\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x70\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\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x70\x00\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\x76\x00\x77\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\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x70\x00\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x70\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\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x70\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\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x8c\x00\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# + +happyTable :: HappyAddr +happyTable = HappyA# "\x00\x00\x04\x00\x02\x00\x05\x00\x93\x00\x02\x00\x17\x01\xfe\x02\x11\x01\x0a\x00\x08\x00\x24\x00\x0a\x00\xb1\x01\x22\x00\x23\x00\x33\x00\x34\x00\x35\x00\x2c\x02\x18\x03\x67\x01\xb7\x02\x29\x02\x29\x00\x24\x00\x67\x01\xf1\x02\xa3\x01\x25\x00\x26\x00\x27\x00\x5d\x01\xce\x01\x0b\x03\x94\x00\x28\x00\xbc\x02\x29\x00\xdf\x01\xe0\x01\x41\x02\x55\x01\x56\x01\x24\x00\x24\x00\xbe\x00\xbd\x02\xbe\x02\x95\x00\x26\x00\x27\x00\x1a\x00\x89\x02\x35\x02\x36\x02\x28\x00\x29\x00\x29\x00\x67\x01\x0c\x03\xd7\x01\x24\x00\x24\x00\xbf\x00\xd4\xff\x43\x01\x26\x00\x27\x00\xbf\x01\xb8\x02\xb9\x02\xba\x02\x28\x00\xb7\x02\x29\x00\x29\x00\x67\x01\x2a\x00\x68\x01\x24\x00\x8f\x02\xcf\x02\x1a\x00\x3e\x02\x20\x02\x96\x00\x24\x00\x00\x03\x1a\x01\x73\x01\x28\x00\x2a\x00\x29\x00\x1a\x00\xc8\x01\x9b\x02\x9c\x02\xab\x02\x7b\x02\x29\x00\xa7\x00\x74\x01\x99\x00\x9a\x00\x9b\x00\x8a\x02\x3e\xff\xd1\x00\x75\x01\x76\x01\x2a\x00\x2a\x00\x1a\x00\xc8\x01\xc0\x01\x56\x02\x38\x00\x9c\x00\x0d\x00\xcf\x01\xc9\x01\x08\x03\xfa\x02\xba\x02\x1a\x00\x3e\x02\x99\x02\xbf\x02\x2a\x00\x2a\x00\x4d\x02\x42\x02\x21\x02\xcf\x01\xd0\x01\x9d\x02\xb2\x01\x36\x00\x96\x02\xcb\x01\x6c\x02\x6d\x02\x0d\x00\x38\x00\x1d\x01\xe1\x01\x2a\x00\xc0\x02\xd0\x01\x36\x00\x37\x00\x38\x00\x39\x00\x2a\x00\x3a\x00\x3b\x00\x69\x01\xbb\x02\x37\x02\x38\x02\xc1\x02\x69\x01\x37\x00\x38\x00\x39\x00\xc3\x02\x3a\x00\x3b\x00\xbf\x02\x3c\x00\x06\x00\x2b\x00\x03\x00\x03\x00\x65\x02\x0b\x00\x0b\x00\x09\x00\x0e\x00\x0b\x00\xce\x01\x3c\x00\x74\x00\x6e\x02\x38\x00\x1d\x01\x8c\x02\x75\x00\xc0\x02\x0f\x00\x39\x02\x2b\x00\xc3\x00\x21\x02\x69\x01\x76\x00\xf9\x02\x21\x02\x1a\x00\x67\x02\xc4\x00\xc1\x02\xac\x00\x3f\x02\xe1\x01\x9d\x02\xed\x01\x1b\x01\x97\x00\xbb\x02\x7c\x02\x1c\x01\x69\x01\x0f\x00\xf8\x02\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xe3\x02\x9a\x00\x9b\x00\x38\x00\x1d\x01\xca\x01\x97\x00\x1e\x01\x5e\x02\x5f\x02\x60\x02\x61\x02\x16\x02\xac\x02\x77\x00\x9e\x00\x78\x00\x79\x00\x19\x01\x1a\x01\x7a\x00\x4f\x00\x50\x00\x17\x03\xcc\x01\x40\x02\xe4\x02\x51\x00\x74\x00\xca\x02\x60\x02\x61\x02\x00\x02\xda\x02\x01\x02\x7b\x00\x77\x00\xd6\x02\x78\x00\x79\x00\xa4\x00\x76\x00\x7a\x00\x4f\x00\x50\x00\x1a\x00\x67\x02\x1a\x00\x4f\x02\x51\x00\x74\x00\x1d\x02\x3b\x00\x4a\x01\x68\x02\x55\x00\x15\x00\x7b\x00\x56\x00\x57\x00\x16\x00\x58\x00\x17\x00\x76\x00\x1a\x00\x89\x02\x21\x00\x8d\x02\x0c\x02\x1a\x00\x4f\x02\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\xa5\x00\x6e\x02\x7c\x00\x57\x00\xb0\x00\x58\x00\x5b\x00\x5c\x00\xde\x00\x3c\x01\xb5\x02\x22\x00\x5c\x00\x62\x02\xf6\x02\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xd7\x02\xd8\x02\xd9\x02\x77\x00\xad\x02\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x62\x02\x16\x02\x38\x00\x9c\x00\x51\x00\x9d\x00\x3b\x00\x8b\x02\x2c\x02\xa5\x00\x69\x02\xd4\x00\x7b\x00\x77\x00\x96\x02\x78\x00\x79\x00\x50\x02\x18\x00\x7a\x00\x4f\x00\x50\x00\x9e\x00\xae\x02\x34\x01\x03\x03\x51\x00\x1b\x01\x0b\x03\xda\x02\xa2\x02\x1c\x01\x55\x00\x35\x01\x7b\x00\x7c\x00\x57\x00\x0c\x02\x58\x00\x51\x02\x19\x00\x04\x03\x36\x01\x38\x00\x1d\x01\x5c\x02\xa0\x02\x1e\x01\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x15\x03\x9b\x00\x7c\x00\x71\x02\x4e\x01\x58\x00\x5b\x00\x5c\x00\x4b\x01\xe5\x01\xd4\x00\x4c\x01\xd6\x00\x4d\x01\x48\x01\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x1b\x01\x6a\x02\x07\x01\x4e\x01\x1c\x01\x9e\x01\x4f\x01\x5b\x00\x5c\x00\x7e\x01\x9b\x00\xd9\x00\x9f\x01\x49\x01\xe6\x01\xe7\x01\x38\x00\x1d\x01\xf0\x02\x13\x00\x1e\x01\xa7\x00\x93\x01\xa9\x00\x9a\x00\x9b\x00\x1c\x02\x94\x01\xab\x00\x95\x01\x76\x01\xa7\x00\x93\x01\xa9\x00\x9a\x00\x9b\x00\x25\x02\x94\x01\xab\x00\x95\x01\x76\x01\x16\x02\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xea\x02\x0f\x03\xab\x00\x2a\x02\xd3\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x2d\x02\x17\x03\xab\x00\x17\x02\x5a\x00\x3b\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xba\x01\x06\x03\xab\x00\x66\x02\xd8\x00\x10\x03\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x98\x02\x13\x03\xab\x00\x44\x01\xe5\x02\xdb\x00\xdc\x00\xdd\x00\x46\x01\x99\x02\xcc\x00\xcd\x00\x38\x00\x9c\x00\x31\x02\x9d\x00\x3b\x00\x3c\x01\x46\x01\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x57\x01\xfd\x02\xab\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x9e\x00\xcc\x02\xab\x00\xf4\x02\x3d\x01\xe6\x02\xe7\x02\xf5\x02\x38\x00\x1d\x01\x38\x00\x9c\x00\xac\x00\x9d\x00\x3b\x00\x32\x02\xea\x01\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xac\x00\x3d\x02\xab\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x9e\x00\x09\x02\xeb\x01\xac\x00\xde\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xdf\x00\x38\x00\x9c\x00\xac\x00\xf1\x01\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xd3\x00\xd4\x00\x33\x01\xac\x00\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x45\x02\xa0\x01\x38\x00\x9c\x00\xac\x00\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xd8\x00\xdd\x02\xd3\x00\xd4\x00\x9e\x00\xe8\x02\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x4e\x02\xdb\x00\xdc\x00\xdd\x00\x9e\x00\x59\x00\xac\x00\x37\x00\x38\x00\x39\x00\x09\x02\x51\x01\xd8\x00\xde\x01\xac\x00\x9e\x00\x1d\x02\x3b\x00\x52\x01\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xdb\x00\xdc\x00\xdd\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xee\x02\x2e\x02\x53\x01\xa2\x01\xac\x00\x38\x00\xec\x01\x9e\x00\x48\x02\xed\x01\x38\x00\x9c\x00\x9c\x01\x2a\x01\x3b\x00\x9e\x00\xd0\x01\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x9d\x01\x4d\x02\xab\x00\xaa\x01\xa6\x01\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x9e\x00\x56\x02\xab\x00\x22\x01\x23\x01\x0b\x02\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x24\x01\x98\x01\xab\x00\x0c\x02\xad\x01\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xbd\x01\x51\x01\xab\x00\x37\x00\x38\x00\x39\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xb5\x01\x56\x01\xab\x00\x40\x00\x41\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xc2\x01\x72\x01\xab\x00\xb9\x01\x0e\x02\x8f\x02\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x24\x01\x77\x01\xab\x00\xd4\x02\xd5\x02\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xd3\x01\xaa\x00\xab\x00\x37\x00\x38\x00\x39\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\xde\x01\xb4\x00\xab\x00\xe8\x01\x9a\xff\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x9a\xff\xdf\x00\xab\x00\xac\x00\x57\xfe\x57\xfe\xc3\x00\x1d\x02\x3b\x00\xf1\x01\x40\x00\x41\x00\xff\x01\xac\x00\xc4\x00\x57\xfe\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xec\x02\x46\x01\x1e\x02\xac\x00\x27\x01\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x40\x00\x41\x00\x5e\x01\xac\x00\x30\x01\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x20\x02\x63\x01\x31\x01\xac\x00\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x07\x02\x66\x01\x32\x01\xac\x00\x08\x02\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x33\x01\xec\x02\xed\x02\xac\x00\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x00\x01\x70\x01\xcf\x00\xac\x00\xd0\x00\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x49\x02\x4a\x02\x4b\x02\xac\x00\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x19\x00\x1a\x00\x1b\x00\xac\x00\x6c\x01\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x1c\x00\x1a\x00\x1b\x00\xe5\x02\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\xa7\x00\xa8\x00\xa9\x00\x9a\x00\x9b\x00\x9e\x00\xec\x00\xab\x00\xa7\x00\x91\x01\x99\x00\x9a\x00\x9b\x00\xb3\x02\xb4\x02\x9e\x00\xba\x01\x92\x01\xbb\x01\xbc\x01\xd2\xfe\x78\x01\xd2\xfe\xd3\x00\xd4\x00\xd5\x00\xd6\x00\x12\x03\x79\x01\xfb\x02\xfc\x02\x99\x00\x9a\x00\x9b\x00\xa7\x00\x47\x02\x99\x00\x9a\x00\x9b\x00\xa7\x00\x57\x02\x99\x00\x9a\x00\x9b\x00\xd8\x00\x39\x01\xd9\x00\xc2\x02\xe3\x01\x3a\x01\xd5\x01\xd6\x01\xd7\x01\xd3\xfe\x3b\x01\xd3\xfe\xdb\x00\xdc\x00\xdd\x00\x7c\x01\xa7\x00\xaf\x01\x99\x00\x9a\x00\x9b\x00\xa7\x00\x8f\x01\x99\x00\x9a\x00\x9b\x00\xa7\x00\x90\x01\x99\x00\x9a\x00\x9b\x00\xcb\x02\xae\x00\x99\x00\x9a\x00\x9b\x00\xc6\x02\xc7\x02\xe1\x00\xaa\x02\xeb\x00\x99\x00\x9a\x00\x9b\x00\x76\x02\x12\x01\x99\x00\x9a\x00\x9b\x00\xa9\x01\x14\x01\x99\x00\x9a\x00\x9b\x00\xe8\x02\x72\x02\x73\x02\xab\x01\xac\x00\x99\x00\x9a\x00\x9b\x00\x74\x02\x75\x02\x87\x02\xe3\x01\xac\x00\x37\x00\x38\x00\x39\x00\x73\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x12\x02\x13\x00\x1e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x23\x02\xe3\x01\xac\x01\xac\x00\x99\x00\x9a\x00\x9b\x00\x9e\x00\xac\x00\xdf\x02\x9a\x00\x9b\x00\x1f\x00\xac\x00\x2f\x00\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x58\x02\xe3\x01\x0f\x00\xac\x00\x03\x02\x9e\x00\xf0\x02\x73\x00\xac\x00\x23\x02\x9e\x00\x05\x02\x08\x03\xac\x00\xea\x01\x9e\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x59\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x55\x01\x9d\x00\x3b\x00\x9e\x00\xde\x02\x9b\x00\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\xe2\x01\xe3\x01\x0a\x03\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\xe4\x00\xb0\x01\x9e\x00\x99\x00\x9a\x00\x9b\x00\x8e\x01\x9e\x00\x99\x00\x9a\x00\x9b\x00\x28\x01\x13\x00\x0e\x03\x98\x00\x9e\x00\x99\x00\x9a\x00\x9b\x00\x8f\x00\x90\x00\xd3\x00\x15\x03\xd5\x00\x38\x00\x9c\x00\x2d\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\xf3\x02\x9d\x00\x3b\x00\x03\x02\xb0\x02\x04\x02\x73\x00\x7e\x01\x9b\x00\x7f\x01\x05\x02\xd8\x00\xf8\x02\x9e\x00\x7d\x02\x9a\x00\x9b\x00\x60\x01\x9e\x00\x7e\x02\xe0\x02\x9a\x00\x9b\x00\xdb\x00\xdc\x00\xdd\x00\x57\xfe\x91\x00\x92\x00\x99\x01\x9a\x00\x9b\x00\x30\x00\x31\x00\x12\x00\x13\x00\x7f\x02\x80\x02\x81\x02\x2d\x00\x82\x02\x00\x03\xe1\x02\x80\x02\x81\x02\x06\x03\x82\x02\xa8\x01\x9a\x00\x9b\x00\x5f\x00\x60\x00\x2d\x00\xa2\x02\x9b\x00\xce\x02\x38\x00\x9c\x00\xcf\x02\x9d\x00\x3b\x00\xe2\x02\x9b\x00\x40\x00\x41\x00\xd1\x02\x9e\x02\x9b\x00\xd2\x02\x57\xfe\x57\xfe\x7e\x01\x9b\x00\x93\x02\x94\x02\x2d\x00\x9e\x00\xa3\x02\x11\x00\x12\x00\x38\x00\x9c\x00\xdc\x02\x9d\x00\x3b\x00\x38\x00\x9c\x00\x40\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x4b\x01\x9d\x00\x3b\x00\x4c\x01\x9b\x02\x18\x02\x38\x00\x9c\x00\xe5\x00\x9d\x00\x3b\x00\x11\x00\x12\x00\x9e\x00\x65\x01\x66\x01\x4e\x01\x2d\x00\x9e\x00\x4f\x01\x94\xfe\x80\x01\xa0\x02\x83\x02\xa6\x02\xcb\x00\x9e\x00\x38\x00\x9c\x00\x83\x02\x9d\x00\x3b\x00\xcc\x00\xcd\x00\x2d\x00\x38\x00\x9c\x00\xb0\x02\x9d\x00\x84\x02\xb7\x02\x38\x00\x9c\x00\xc9\x02\x9d\x00\x84\x02\x5a\x02\x9e\x00\x81\x01\x82\x01\x38\x00\x9c\x00\x5e\x02\x9d\x00\x3b\x00\x9e\x00\x0e\x01\x0f\x01\x29\x01\x38\x00\x39\x00\x9e\x00\x2a\x01\x3b\x00\x11\x00\x12\x00\x64\x02\x65\x02\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x74\xff\x9d\x00\x3b\x00\x6c\x02\x71\x02\x2d\x00\x38\x00\x9c\x00\x79\x02\x9d\x00\x3b\x00\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\x38\x00\x9c\x00\x9e\x00\x9d\x00\x3b\x00\x44\x01\x78\x02\x7b\x02\x89\x02\xce\x01\x9e\x00\x23\x02\xcc\x00\xcd\x00\x00\x01\x9e\x00\xcf\x00\x95\x02\xd0\x00\x0e\x02\x9e\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x05\x01\xd4\x00\xd5\x00\xd6\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x06\x01\x5a\x01\x38\x00\x39\x00\x36\x01\x2a\x01\x3b\x00\x67\x00\x15\x02\x07\x01\x68\x00\x08\x01\x09\x01\x16\x02\xd9\x00\x18\x02\x1a\x02\xbb\x00\x1b\x02\x1c\x02\xea\x01\x23\x02\x69\x00\x25\x02\x0a\x01\x0b\x01\x0c\x01\x6a\x00\x27\x02\x28\x02\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x29\x02\x71\x00\x72\x00\x6b\x01\x30\x02\x44\x02\x73\x00\x34\x02\x35\x02\x3e\x00\x3f\x00\x55\x02\xa0\x01\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x45\x02\x53\x02\x9b\x01\x42\x00\x87\x00\x75\xff\xa6\x01\x55\x01\x4b\x00\xbc\x00\xa2\x01\x6b\x01\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xbd\x00\x8d\x00\xa8\x01\xb7\x01\xaf\x01\xb8\x01\x75\xff\xb9\x01\x4d\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\xd7\x00\xd8\x00\x55\x01\xd9\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\xbf\x01\xc2\x01\xc8\x01\x2d\x00\xdb\x00\xdc\x00\xdd\x00\x57\xfe\x6b\x01\xde\x01\x57\xfe\xce\x01\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xea\x01\xef\x01\xf0\x01\x57\xfe\x2d\x01\x57\xfe\xe8\x01\xfd\x01\x57\xfe\x4b\x00\xfe\x01\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\xff\x01\x57\xfe\x57\xfe\x09\x02\x57\xfe\x19\x01\x57\xfe\x06\x02\x4d\x00\x3e\x00\x61\xfe\x63\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x62\xfe\x65\xfe\x68\xfe\x57\xfe\x37\x01\x57\xfe\x2c\x01\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x2d\x01\x57\xfe\x2f\x01\x57\xfe\x38\x01\x3e\x01\x57\xfe\x3f\x01\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x40\x01\x42\x01\x43\x01\x46\x01\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x6b\x01\x5c\x01\x57\xfe\x4a\x01\x60\x01\x63\x01\x72\x01\x57\xfe\x70\x01\x7b\x01\x57\xfe\x98\x01\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7e\x01\x7c\x01\x2d\x00\x57\xfe\xa7\x00\x57\xfe\xb0\x00\xa7\x00\x57\xfe\x4b\x00\xb3\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\xb4\x00\x57\xfe\x57\xfe\xb2\x00\x57\xfe\xe3\x00\x57\xfe\x0d\x01\x4d\x00\x10\x01\x11\x01\x0d\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x14\x01\x16\x01\x17\x01\x57\xfe\x2e\x00\x57\xfe\x33\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x4e\x00\x57\xfe\x0e\x00\x57\xfe\x1e\x00\x08\x00\x57\xfe\xff\xff\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x2f\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\xc8\x00\x00\x00\x00\x00\xc9\x00\x00\x00\xca\x00\x57\xfe\xcb\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x00\xcd\x00\xce\x00\x00\x00\xcf\x00\x00\x00\xd0\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\xc5\x00\xc6\x00\xc7\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\xc8\x00\x00\x00\x00\x00\xc9\x00\x00\x00\xca\x00\x67\x00\xcb\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x00\xcd\x00\xce\x00\x00\x00\xcf\x00\x00\x00\xd0\x00\x69\x00\xd1\x00\x7f\x00\x00\x00\xe8\x00\x6a\x00\x00\x00\xe9\x00\x6b\x00\x80\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x37\x00\x38\x00\x39\x00\x73\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x81\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x88\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x00\x00\x8d\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\xc8\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x6d\x01\x67\x00\xcb\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x00\xcd\x00\xce\x00\x00\x00\xcf\x00\x00\x00\xd0\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x80\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x00\x00\x8d\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x4d\x00\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\x00\x00\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xee\xfe\x00\x00\x00\x00\xee\xfe\x00\x00\x00\x00\xee\xfe\xee\xfe\xee\xfe\x00\x00\xee\xfe\x00\x00\xee\xfe\x00\x00\xee\xfe\x3e\x00\x00\x00\x00\x00\xee\xfe\x40\x00\xee\xfe\xee\xfe\xee\xfe\xee\xfe\x00\x00\x00\x00\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\x00\x00\xee\xfe\xee\xfe\x00\x00\xee\xfe\x00\x00\xee\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\xee\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\xee\xfe\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\xee\xfe\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x42\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\xea\x02\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x42\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x26\x01\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x4b\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x4d\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\xd3\x02\x00\x00\xb4\x01\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x00\x00\xa9\x02\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x02\x00\x00\x4d\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x42\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x57\xfe\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x59\x01\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\xb4\x01\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x01\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x4b\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x57\xfe\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x57\xfe\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\xf8\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\xd2\x01\xd3\x01\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x4b\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\xd3\x01\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x4b\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\xc8\x00\xc5\x02\x00\x00\xc9\x00\x87\x00\x40\x01\x00\x00\xcb\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x00\xcd\x00\xce\x00\x8d\x00\xcf\x00\x8e\x00\xd0\x00\x00\x00\xc6\x02\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\xc8\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x6d\x01\x67\x00\xcb\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x00\xcd\x00\xce\x00\x00\x00\xcf\x00\x00\x00\xd0\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\xd7\x00\xd8\x00\x4b\x00\xd9\x00\x6f\x01\x00\x00\x89\x00\x8a\x00\x8b\x00\x00\x00\x00\x00\x8d\x00\x00\x00\xdb\x00\xdc\x00\xdd\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x57\xfe\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x01\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x57\xfe\x57\xfe\x00\x00\x57\xfe\x00\x00\x57\xfe\xd3\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\x00\x00\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x57\xfe\x00\x00\xd7\x00\xd8\x00\x57\xfe\xd9\x00\x6f\x01\x00\x00\x00\x00\x00\x00\xaf\xfe\x00\x00\x00\x00\x57\xfe\x00\x00\xdb\x00\xdc\x00\xdd\x00\x00\x00\x00\x00\x57\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\xd7\x00\xd8\x00\x4b\x00\xd9\x00\x00\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\xdb\x00\xdc\x00\xdd\x00\x00\x00\x00\x00\x4d\x00\x5e\x00\x3f\x00\x5f\x00\x60\x00\x61\x00\x41\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\xca\xfe\xca\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x18\x00\x00\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x4d\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x3e\x00\x3f\x00\x00\x00\x73\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3d\x02\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x4b\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x4d\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x69\x00\x40\x00\x41\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x57\xfe\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x4d\x00\x68\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x4b\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x84\x01\xd4\x00\x4b\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x4d\x00\x00\x00\x85\x01\x47\x02\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x01\x00\x00\x87\x01\x78\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\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x4b\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\xa0\x00\x48\x01\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\xa2\x00\x3e\x00\x07\x01\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x84\x01\xd4\x00\x00\x00\xd6\x00\x00\x00\x49\x01\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\xa2\x00\x00\x00\x00\x00\x40\x00\x85\x01\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x01\x59\x01\x97\x01\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x4b\x00\x00\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x4d\x00\xa0\x00\x48\x01\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xa2\x00\x00\x00\x07\x01\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x49\x01\x00\x00\x4d\x00\x40\x00\x41\x00\x00\x00\x00\x00\x50\xff\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x4d\x00\x00\x00\x50\xff\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\xa7\x02\x78\xff\x00\x00\xa8\x02\xc3\x01\x5c\x01\x79\x00\xae\x00\x4b\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\xa0\x00\x58\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x4d\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x5b\x00\x5c\x00\x12\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\xae\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x4d\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\xae\x00\x4b\x00\x40\x00\x41\x00\x00\x00\x3e\x00\x50\xff\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x4d\x00\x00\x00\x00\x00\xa0\x00\xa2\x00\xa1\x00\x00\x00\x00\x00\x50\xff\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\xa8\x02\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x46\x01\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\xae\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x4d\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x3e\x00\x4d\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa2\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x4b\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x40\x00\x41\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x4d\x00\x86\x02\x00\x00\xa1\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x4b\x00\xa2\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x4d\x00\x00\x00\x3e\x00\x87\x02\x00\x00\xa2\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x01\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x87\x02\x00\x00\x40\x00\x41\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x4b\x00\xa2\x00\x40\x00\x41\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x86\x02\x00\x00\xa1\x00\x4d\x00\x00\x00\x3e\x00\xa5\x02\x4b\x00\xa2\x00\x40\x00\x41\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x4d\x00\x00\x00\x00\x00\x87\x02\x4b\x00\xa2\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\xff\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x00\x00\x4b\x00\x40\x00\x41\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x42\x00\x00\x00\x3e\x00\x00\x00\x4d\x00\x00\x00\x40\x00\x41\x00\x4b\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x3e\x00\x3f\x00\x4d\x00\xa2\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x4d\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa1\x00\x4d\x00\x00\x00\x3e\x00\x00\x00\x4b\x00\xa2\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x20\x01\x02\x03\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x03\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x01\x21\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x22\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x3f\x00\x4d\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x4d\x00\x40\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x59\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xd8\x01\xc0\x00\xb6\x00\xb7\x00\x88\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x0e\x03\xda\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\xd8\x01\xc0\x00\xb6\x00\xb7\x00\x88\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\xd9\x01\xda\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\xd8\x01\xc0\x00\xb6\x00\xb7\x00\x88\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\xf2\x01\xda\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\xd8\x01\xc0\x00\xb6\x00\xb7\x00\x88\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\xf4\x01\xda\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x87\x01\xc0\x00\xb6\x00\xb7\x00\x88\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x01\x00\x00\xc9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x87\x01\xc0\x00\xb6\x00\xb7\x00\x88\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x01\x00\x00\x5a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\xd8\x01\xc0\x00\xb6\x00\xb7\x00\x88\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x90\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x87\x01\xc0\x00\xb6\x00\xb7\x00\x88\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x01\x00\x00\x53\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x87\x01\xc0\x00\xb6\x00\xb7\x00\x88\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x01\x00\x00\xa4\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x87\x01\xc0\x00\xb6\x00\xb7\x00\x88\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x01\x00\x00\x8a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x87\x01\xc0\x00\xb6\x00\xb7\x00\x88\x01\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x01\x00\x00\x8d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x19\x03\xc0\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\xf6\x02\xc0\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\xdc\x02\xc0\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\xa9\x02\xc0\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5b\x02\xc0\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x79\x02\xc0\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x59\x01\xc0\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\xbf\x00\xc0\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\xef\x00\xc0\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\xf0\x00\xc0\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf8\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\xf9\x00\xfa\x00\x00\x00\xfb\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\xfc\x00\x00\x00\xfd\x00\x00\x00\x00\x00\xfe\x00\xff\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xcc\x00\xcd\x00\x00\x01\x01\x01\xcf\x00\x02\x01\x03\x01\x5b\x00\x5c\x00\xf4\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\xf5\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x10\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x11\x02\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf8\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\xf9\x01\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf1\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\xf2\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xb0\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x6f\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x91\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x0f\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x30\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x3a\x02\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf3\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf5\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf6\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf7\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xfa\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xfb\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x6b\x01\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xe3\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x2d\x01\xb7\x00\xee\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\xed\x00\xb7\x00\xee\x00\xb9\x00\x78\x00\x79\x00\x5b\x00\x5c\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\xb1\x02\x00\x00\x78\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x7b\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x02\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x5c\x01\x79\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x00\x00\x00\x00\x00\x7a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xc4\x01\xc5\x01\xc6\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x02\xc6\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x51\x00\x00\x00\x00\x00\x52\x00\x13\x00\x00\x00\x53\x00\x13\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x51\x00\x00\x00\x00\x00\x52\x00\x13\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x60\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\xc4\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyReduceArr = array (1, 436) [ + (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) + ] + +happy_n_terms = 100 :: Int +happy_n_nonterms = 180 :: Int + +happyReduce_1 = happyMonadReduce 1# 0# happyReduction_1 +happyReduction_1 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut5 happy_x_1 of { happy_var_1 -> + ( checkExpr happy_var_1 >>= mkPageModule)} + ) (\r -> happyReturn (happyIn4 r)) + +happyReduce_2 = happyMonadReduce 5# 0# happyReduction_2 +happyReduction_2 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut6 happy_x_2 of { happy_var_2 -> + case happyOut174 happy_x_4 of { happy_var_4 -> + case happyOut5 happy_x_5 of { happy_var_5 -> + ( checkExpr happy_var_5 >>= \x -> mkPage happy_var_2 happy_var_4 x)}}} + ) (\r -> happyReturn (happyIn4 r)) + +happyReduce_3 = happySpecReduce_1 0# happyReduction_3 +happyReduction_3 happy_x_1 + = case happyOut6 happy_x_1 of { happy_var_1 -> + happyIn4 + (happy_var_1 + )} + +happyReduce_4 = happyMonadReduce 10# 1# happyReduction_4 +happyReduction_4 (happy_x_10 `HappyStk` + happy_x_9 `HappyStk` + happy_x_8 `HappyStk` + happy_x_7 `HappyStk` + happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut119 happy_x_3 of { happy_var_3 -> + case happyOut121 happy_x_4 of { happy_var_4 -> + case happyOut123 happy_x_5 of { happy_var_5 -> + case happyOut117 happy_x_7 of { happy_var_7 -> + case happyOut119 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 happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut119 happy_x_3 of { happy_var_3 -> + case happyOut121 happy_x_4 of { happy_var_4 -> + case happyOut123 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 = happyReduce 6# 2# happyReduction_6 +happyReduction_6 (happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut177 happy_x_3 of { happy_var_3 -> + case happyOut11 happy_x_4 of { happy_var_4 -> + case happyOut7 happy_x_6 of { happy_var_6 -> + happyIn6 + (Module happy_var_1 happy_var_3 happy_var_4 (fst happy_var_6) (snd happy_var_6) + ) `HappyStk` happyRest}}}} + +happyReduce_7 = happySpecReduce_2 2# happyReduction_7 +happyReduction_7 happy_x_2 + happy_x_1 + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn6 + (Module happy_var_1 main_mod (Just [EVar (UnQual main_name)]) + (fst happy_var_2) (snd happy_var_2) + )}} + +happyReduce_8 = happySpecReduce_3 3# happyReduction_8 +happyReduction_8 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn7 + (happy_var_2 + )} + +happyReduce_9 = happySpecReduce_3 3# happyReduction_9 +happyReduction_9 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn7 + (happy_var_2 + )} + +happyReduce_10 = happyReduce 4# 4# happyReduction_10 +happyReduction_10 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut16 happy_x_2 of { happy_var_2 -> + case happyOut31 happy_x_4 of { happy_var_4 -> + happyIn8 + ((reverse happy_var_2, happy_var_4) + ) `HappyStk` happyRest}} + +happyReduce_11 = happySpecReduce_2 4# happyReduction_11 +happyReduction_11 happy_x_2 + happy_x_1 + = case happyOut31 happy_x_2 of { happy_var_2 -> + happyIn8 + (([], happy_var_2) + )} + +happyReduce_12 = happySpecReduce_3 4# happyReduction_12 +happyReduction_12 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn8 + ((reverse happy_var_2, []) + )} + +happyReduce_13 = happySpecReduce_1 4# happyReduction_13 +happyReduction_13 happy_x_1 + = happyIn8 + (([], []) + ) + +happyReduce_14 = happySpecReduce_2 5# happyReduction_14 +happyReduction_14 happy_x_2 + happy_x_1 + = happyIn9 + (() + ) + +happyReduce_15 = happySpecReduce_1 6# happyReduction_15 +happyReduction_15 happy_x_1 + = happyIn10 + (() + ) + +happyReduce_16 = happySpecReduce_0 6# happyReduction_16 +happyReduction_16 = happyIn10 + (() + ) + +happyReduce_17 = happySpecReduce_1 7# happyReduction_17 +happyReduction_17 happy_x_1 + = case happyOut12 happy_x_1 of { happy_var_1 -> + happyIn11 + (Just happy_var_1 + )} + +happyReduce_18 = happySpecReduce_0 7# happyReduction_18 +happyReduction_18 = happyIn11 + (Nothing + ) + +happyReduce_19 = happyReduce 4# 8# happyReduction_19 +happyReduction_19 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut14 happy_x_2 of { happy_var_2 -> + happyIn12 + (reverse happy_var_2 + ) `HappyStk` happyRest} + +happyReduce_20 = happySpecReduce_3 8# happyReduction_20 +happyReduction_20 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn12 + ([] + ) + +happyReduce_21 = happySpecReduce_1 9# happyReduction_21 +happyReduction_21 happy_x_1 + = happyIn13 + (() + ) + +happyReduce_22 = happySpecReduce_0 9# happyReduction_22 +happyReduction_22 = happyIn13 + (() + ) + +happyReduce_23 = happySpecReduce_3 10# happyReduction_23 +happyReduction_23 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut14 happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_3 of { happy_var_3 -> + happyIn14 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_24 = happySpecReduce_1 10# happyReduction_24 +happyReduction_24 happy_x_1 + = case happyOut15 happy_x_1 of { happy_var_1 -> + happyIn14 + ([happy_var_1] + )} + +happyReduce_25 = happySpecReduce_1 11# happyReduction_25 +happyReduction_25 happy_x_1 + = case happyOut147 happy_x_1 of { happy_var_1 -> + happyIn15 + (EVar happy_var_1 + )} + +happyReduce_26 = happySpecReduce_1 11# happyReduction_26 +happyReduction_26 happy_x_1 + = case happyOut179 happy_x_1 of { happy_var_1 -> + happyIn15 + (EAbs happy_var_1 + )} + +happyReduce_27 = happyReduce 4# 11# happyReduction_27 +happyReduction_27 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut179 happy_x_1 of { happy_var_1 -> + happyIn15 + (EThingAll happy_var_1 + ) `HappyStk` happyRest} + +happyReduce_28 = happySpecReduce_3 11# happyReduction_28 +happyReduction_28 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut179 happy_x_1 of { happy_var_1 -> + happyIn15 + (EThingWith happy_var_1 [] + )} + +happyReduce_29 = happyReduce 4# 11# happyReduction_29 +happyReduction_29 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut179 happy_x_1 of { happy_var_1 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn15 + (EThingWith happy_var_1 (reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_30 = happySpecReduce_2 11# happyReduction_30 +happyReduction_30 happy_x_2 + happy_x_1 + = case happyOut177 happy_x_2 of { happy_var_2 -> + happyIn15 + (EModuleContents happy_var_2 + )} + +happyReduce_31 = happySpecReduce_3 12# happyReduction_31 +happyReduction_31 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut16 happy_x_1 of { happy_var_1 -> + case happyOut17 happy_x_3 of { happy_var_3 -> + happyIn16 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_32 = happySpecReduce_1 12# happyReduction_32 +happyReduction_32 happy_x_1 + = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn16 + ([happy_var_1] + )} + +happyReduce_33 = happyReduce 6# 13# happyReduction_33 +happyReduction_33 (happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut18 happy_x_3 of { happy_var_3 -> + case happyOut177 happy_x_4 of { happy_var_4 -> + case happyOut19 happy_x_5 of { happy_var_5 -> + case happyOut20 happy_x_6 of { happy_var_6 -> + happyIn17 + (ImportDecl happy_var_1 happy_var_4 happy_var_3 happy_var_5 happy_var_6 + ) `HappyStk` happyRest}}}}} + +happyReduce_34 = happySpecReduce_1 14# happyReduction_34 +happyReduction_34 happy_x_1 + = happyIn18 + (True + ) + +happyReduce_35 = happySpecReduce_0 14# happyReduction_35 +happyReduction_35 = happyIn18 + (False + ) + +happyReduce_36 = happySpecReduce_2 15# happyReduction_36 +happyReduction_36 happy_x_2 + happy_x_1 + = case happyOut177 happy_x_2 of { happy_var_2 -> + happyIn19 + (Just happy_var_2 + )} + +happyReduce_37 = happySpecReduce_0 15# happyReduction_37 +happyReduction_37 = happyIn19 + (Nothing + ) + +happyReduce_38 = happySpecReduce_1 16# happyReduction_38 +happyReduction_38 happy_x_1 + = case happyOut21 happy_x_1 of { happy_var_1 -> + happyIn20 + (Just happy_var_1 + )} + +happyReduce_39 = happySpecReduce_0 16# happyReduction_39 +happyReduction_39 = happyIn20 + (Nothing + ) + +happyReduce_40 = happyReduce 5# 17# happyReduction_40 +happyReduction_40 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_3 of { happy_var_3 -> + happyIn21 + ((happy_var_1, reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_41 = happyReduce 4# 17# happyReduction_41 +happyReduction_41 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut22 happy_x_1 of { happy_var_1 -> + happyIn21 + ((happy_var_1, []) + ) `HappyStk` happyRest} + +happyReduce_42 = happySpecReduce_1 18# happyReduction_42 +happyReduction_42 happy_x_1 + = happyIn22 + (True + ) + +happyReduce_43 = happySpecReduce_0 18# happyReduction_43 +happyReduction_43 = happyIn22 + (False + ) + +happyReduce_44 = happySpecReduce_3 19# happyReduction_44 +happyReduction_44 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut23 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn23 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_45 = happySpecReduce_1 19# happyReduction_45 +happyReduction_45 happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn23 + ([happy_var_1] + )} + +happyReduce_46 = happySpecReduce_1 20# happyReduction_46 +happyReduction_46 happy_x_1 + = case happyOut145 happy_x_1 of { happy_var_1 -> + happyIn24 + (IVar happy_var_1 + )} + +happyReduce_47 = happySpecReduce_1 20# happyReduction_47 +happyReduction_47 happy_x_1 + = case happyOut178 happy_x_1 of { happy_var_1 -> + happyIn24 + (IAbs happy_var_1 + )} + +happyReduce_48 = happyReduce 4# 20# happyReduction_48 +happyReduction_48 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut178 happy_x_1 of { happy_var_1 -> + happyIn24 + (IThingAll happy_var_1 + ) `HappyStk` happyRest} + +happyReduce_49 = happySpecReduce_3 20# happyReduction_49 +happyReduction_49 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut178 happy_x_1 of { happy_var_1 -> + happyIn24 + (IThingWith happy_var_1 [] + )} + +happyReduce_50 = happyReduce 4# 20# happyReduction_50 +happyReduction_50 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut178 happy_x_1 of { happy_var_1 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn24 + (IThingWith happy_var_1 (reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_51 = happySpecReduce_3 21# happyReduction_51 +happyReduction_51 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut26 happy_x_3 of { happy_var_3 -> + happyIn25 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_52 = happySpecReduce_1 21# happyReduction_52 +happyReduction_52 happy_x_1 + = case happyOut26 happy_x_1 of { happy_var_1 -> + happyIn25 + ([happy_var_1] + )} + +happyReduce_53 = happySpecReduce_1 22# happyReduction_53 +happyReduction_53 happy_x_1 + = case happyOut145 happy_x_1 of { happy_var_1 -> + happyIn26 + (VarName happy_var_1 + )} + +happyReduce_54 = happySpecReduce_1 22# happyReduction_54 +happyReduction_54 happy_x_1 + = case happyOut149 happy_x_1 of { happy_var_1 -> + happyIn26 + (ConName happy_var_1 + )} + +happyReduce_55 = happyReduce 4# 23# happyReduction_55 +happyReduction_55 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut29 happy_x_2 of { happy_var_2 -> + case happyOut28 happy_x_3 of { happy_var_3 -> + case happyOut30 happy_x_4 of { happy_var_4 -> + happyIn27 + (InfixDecl happy_var_1 happy_var_2 happy_var_3 (reverse happy_var_4) + ) `HappyStk` happyRest}}}} + +happyReduce_56 = happySpecReduce_0 24# happyReduction_56 +happyReduction_56 = happyIn28 + (9 + ) + +happyReduce_57 = happyMonadReduce 1# 24# happyReduction_57 +happyReduction_57 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> + ( checkPrec happy_var_1)} + ) (\r -> happyReturn (happyIn28 r)) + +happyReduce_58 = happySpecReduce_1 25# happyReduction_58 +happyReduction_58 happy_x_1 + = happyIn29 + (AssocNone + ) + +happyReduce_59 = happySpecReduce_1 25# happyReduction_59 +happyReduction_59 happy_x_1 + = happyIn29 + (AssocLeft + ) + +happyReduce_60 = happySpecReduce_1 25# happyReduction_60 +happyReduction_60 happy_x_1 + = happyIn29 + (AssocRight + ) + +happyReduce_61 = happySpecReduce_3 26# happyReduction_61 +happyReduction_61 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut30 happy_x_1 of { happy_var_1 -> + case happyOut156 happy_x_3 of { happy_var_3 -> + happyIn30 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_62 = happySpecReduce_1 26# happyReduction_62 +happyReduction_62 happy_x_1 + = case happyOut156 happy_x_1 of { happy_var_1 -> + happyIn30 + ([happy_var_1] + )} + +happyReduce_63 = happyMonadReduce 2# 27# happyReduction_63 +happyReduction_63 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut32 happy_x_1 of { happy_var_1 -> + ( checkRevDecls happy_var_1)} + ) (\r -> happyReturn (happyIn31 r)) + +happyReduce_64 = happySpecReduce_3 28# happyReduction_64 +happyReduction_64 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut32 happy_x_1 of { happy_var_1 -> + case happyOut33 happy_x_3 of { happy_var_3 -> + happyIn32 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_65 = happySpecReduce_1 28# happyReduction_65 +happyReduction_65 happy_x_1 + = case happyOut33 happy_x_1 of { happy_var_1 -> + happyIn32 + ([happy_var_1] + )} + +happyReduce_66 = happyMonadReduce 5# 29# happyReduction_66 +happyReduction_66 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + case happyOut52 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 (happyIn33 r)) + +happyReduce_67 = happyMonadReduce 5# 29# happyReduction_67 +happyReduction_67 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut47 happy_x_4 of { happy_var_4 -> + case happyOut82 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 (happyIn33 r)) + +happyReduce_68 = happyMonadReduce 6# 29# happyReduction_68 +happyReduction_68 (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 happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_4 of { happy_var_4 -> + case happyOut52 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 (happyIn33 r)) + +happyReduce_69 = happyMonadReduce 5# 29# happyReduction_69 +happyReduction_69 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut34 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_3 of { happy_var_3 -> + case happyOut66 happy_x_4 of { happy_var_4 -> + case happyOut78 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 (happyIn33 r)) + +happyReduce_70 = happyMonadReduce 6# 29# happyReduction_70 +happyReduction_70 (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 happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut34 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_3 of { happy_var_3 -> + case happyOut82 happy_x_4 of { happy_var_4 -> + case happyOut62 happy_x_6 of { happy_var_6 -> + ( 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)) })}}}}} + ) (\r -> happyReturn (happyIn33 r)) + +happyReduce_71 = happyMonadReduce 5# 29# happyReduction_71 +happyReduction_71 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut52 happy_x_4 of { happy_var_4 -> + case happyOut82 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 (happyIn33 r)) + +happyReduce_72 = happyMonadReduce 6# 29# happyReduction_72 +happyReduction_72 (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 happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut34 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_4 of { happy_var_4 -> + case happyOut66 happy_x_5 of { happy_var_5 -> + case happyOut78 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 (happyIn33 r)) + +happyReduce_73 = happyMonadReduce 7# 29# happyReduction_73 +happyReduction_73 (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 happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut34 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_4 of { happy_var_4 -> + case happyOut82 happy_x_5 of { happy_var_5 -> + case happyOut62 happy_x_7 of { happy_var_7 -> + ( 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)) })}}}}} + ) (\r -> happyReturn (happyIn33 r)) + +happyReduce_74 = happyMonadReduce 5# 29# happyReduction_74 +happyReduction_74 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut52 happy_x_3 of { happy_var_3 -> + case happyOut59 happy_x_4 of { happy_var_4 -> + case happyOut83 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 (happyIn33 r)) + +happyReduce_75 = happyMonadReduce 4# 29# happyReduction_75 +happyReduction_75 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut52 happy_x_3 of { happy_var_3 -> + case happyOut89 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 (happyIn33 r)) + +happyReduce_76 = happyMonadReduce 4# 29# happyReduction_76 +happyReduction_76 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut52 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 (happyIn33 r)) + +happyReduce_77 = happyReduce 5# 29# happyReduction_77 +happyReduction_77 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_4 of { happy_var_4 -> + happyIn33 + (DefaultDecl happy_var_1 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_78 = happyReduce 4# 29# happyReduction_78 +happyReduction_78 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut99 happy_x_3 of { happy_var_3 -> + happyIn33 + (SpliceDecl happy_var_1 $ ParenSplice happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_79 = happyReduce 6# 29# happyReduction_79 +happyReduction_79 (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 happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut43 happy_x_4 of { happy_var_4 -> + case happyOut44 happy_x_5 of { happy_var_5 -> + case happyOut45 happy_x_6 of { happy_var_6 -> + happyIn33 + (let (s,n,t) = happy_var_6 in ForImp happy_var_1 happy_var_4 happy_var_5 s n t + ) `HappyStk` happyRest}}}} + +happyReduce_80 = happyReduce 5# 29# happyReduction_80 +happyReduction_80 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut43 happy_x_4 of { happy_var_4 -> + case happyOut45 happy_x_5 of { happy_var_5 -> + happyIn33 + (let (s,n,t) = happy_var_5 in ForExp happy_var_1 happy_var_4 s n t + ) `HappyStk` happyRest}}} + +happyReduce_81 = happySpecReduce_1 29# happyReduction_81 +happyReduction_81 happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + happyIn33 + (happy_var_1 + )} + +happyReduce_82 = happySpecReduce_1 30# happyReduction_82 +happyReduction_82 happy_x_1 + = happyIn34 + (DataType + ) + +happyReduce_83 = happySpecReduce_1 30# happyReduction_83 +happyReduction_83 happy_x_1 + = happyIn34 + (NewType + ) + +happyReduce_84 = happySpecReduce_1 31# happyReduction_84 +happyReduction_84 happy_x_1 + = case happyOut54 happy_x_1 of { happy_var_1 -> + happyIn35 + (reverse happy_var_1 + )} + +happyReduce_85 = happySpecReduce_1 31# happyReduction_85 +happyReduction_85 happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + happyIn35 + ([happy_var_1] + )} + +happyReduce_86 = happySpecReduce_0 31# happyReduction_86 +happyReduction_86 = happyIn35 + ([] + ) + +happyReduce_87 = happyMonadReduce 3# 32# happyReduction_87 +happyReduction_87 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut37 happy_x_2 of { happy_var_2 -> + ( checkRevDecls happy_var_2)} + ) (\r -> happyReturn (happyIn36 r)) + +happyReduce_88 = happySpecReduce_1 32# happyReduction_88 +happyReduction_88 happy_x_1 + = happyIn36 + ([] + ) + +happyReduce_89 = happySpecReduce_3 33# happyReduction_89 +happyReduction_89 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_90 = happySpecReduce_1 33# happyReduction_90 +happyReduction_90 happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + happyIn37 + ([happy_var_1] + )} + +happyReduce_91 = happySpecReduce_1 34# happyReduction_91 +happyReduction_91 happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + happyIn38 + (happy_var_1 + )} + +happyReduce_92 = happySpecReduce_1 34# happyReduction_92 +happyReduction_92 happy_x_1 + = case happyOut27 happy_x_1 of { happy_var_1 -> + happyIn38 + (happy_var_1 + )} + +happyReduce_93 = happySpecReduce_1 34# happyReduction_93 +happyReduction_93 happy_x_1 + = case happyOut94 happy_x_1 of { happy_var_1 -> + happyIn38 + (happy_var_1 + )} + +happyReduce_94 = happySpecReduce_3 35# happyReduction_94 +happyReduction_94 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut36 happy_x_2 of { happy_var_2 -> + happyIn39 + (happy_var_2 + )} + +happyReduce_95 = happySpecReduce_3 35# happyReduction_95 +happyReduction_95 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut36 happy_x_2 of { happy_var_2 -> + happyIn39 + (happy_var_2 + )} + +happyReduce_96 = happyReduce 4# 36# happyReduction_96 +happyReduction_96 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut42 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_4 of { happy_var_4 -> + happyIn40 + (TypeSig happy_var_1 (reverse happy_var_2) happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_97 = happySpecReduce_1 37# happyReduction_97 +happyReduction_97 happy_x_1 + = case happyOut39 happy_x_1 of { happy_var_1 -> + happyIn41 + (BDecls happy_var_1 + )} + +happyReduce_98 = happySpecReduce_3 37# happyReduction_98 +happyReduction_98 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut141 happy_x_2 of { happy_var_2 -> + happyIn41 + (IPBinds happy_var_2 + )} + +happyReduce_99 = happySpecReduce_3 37# happyReduction_99 +happyReduction_99 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut141 happy_x_2 of { happy_var_2 -> + happyIn41 + (IPBinds happy_var_2 + )} + +happyReduce_100 = happySpecReduce_3 38# happyReduction_100 +happyReduction_100 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut42 happy_x_1 of { happy_var_1 -> + case happyOut145 happy_x_3 of { happy_var_3 -> + happyIn42 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_101 = happyMonadReduce 1# 38# happyReduction_101 +happyReduction_101 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut147 happy_x_1 of { happy_var_1 -> + ( do { n <- checkUnQual happy_var_1; + return [n] })} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_102 = happySpecReduce_1 39# happyReduction_102 +happyReduction_102 happy_x_1 + = happyIn43 + (StdCall + ) + +happyReduce_103 = happySpecReduce_1 39# happyReduction_103 +happyReduction_103 happy_x_1 + = happyIn43 + (CCall + ) + +happyReduce_104 = happySpecReduce_1 40# happyReduction_104 +happyReduction_104 happy_x_1 + = happyIn44 + (PlaySafe False + ) + +happyReduce_105 = happySpecReduce_1 40# happyReduction_105 +happyReduction_105 happy_x_1 + = happyIn44 + (PlayRisky + ) + +happyReduce_106 = happySpecReduce_1 40# happyReduction_106 +happyReduction_106 happy_x_1 + = happyIn44 + (PlaySafe True + ) + +happyReduce_107 = happySpecReduce_0 40# happyReduction_107 +happyReduction_107 = happyIn44 + (PlaySafe False + ) + +happyReduce_108 = happyReduce 4# 41# happyReduction_108 +happyReduction_108 (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 happyOut146 happy_x_2 of { happy_var_2 -> + case happyOut46 happy_x_4 of { happy_var_4 -> + happyIn45 + ((happy_var_1, happy_var_2, happy_var_4) + ) `HappyStk` happyRest}}} + +happyReduce_109 = happySpecReduce_3 41# happyReduction_109 +happyReduction_109 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut146 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + happyIn45 + (("", happy_var_1, happy_var_3) + )}} + +happyReduce_110 = happySpecReduce_1 42# happyReduction_110 +happyReduction_110 happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + happyIn46 + (happy_var_1 + )} + +happyReduce_111 = happySpecReduce_3 42# happyReduction_111 +happyReduction_111 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut51 happy_x_2 of { happy_var_2 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + happyIn46 + (TyInfix happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_112 = happySpecReduce_3 42# happyReduction_112 +happyReduction_112 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut182 happy_x_2 of { happy_var_2 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + happyIn46 + (TyInfix happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_113 = happySpecReduce_3 42# happyReduction_113 +happyReduction_113 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + happyIn46 + (TyFun happy_var_1 happy_var_3 + )}} + +happyReduce_114 = happySpecReduce_3 42# happyReduction_114 +happyReduction_114 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut48 happy_x_3 of { happy_var_3 -> + happyIn46 + (TyPred $ EqualP happy_var_1 happy_var_3 + )}} + +happyReduce_115 = happySpecReduce_3 43# happyReduction_115 +happyReduction_115 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut148 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + happyIn47 + (TyPred $ IParam happy_var_1 happy_var_3 + )}} + +happyReduce_116 = happySpecReduce_1 43# happyReduction_116 +happyReduction_116 happy_x_1 + = case happyOut46 happy_x_1 of { happy_var_1 -> + happyIn47 + (happy_var_1 + )} + +happyReduce_117 = happySpecReduce_2 44# happyReduction_117 +happyReduction_117 happy_x_2 + happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut49 happy_x_2 of { happy_var_2 -> + happyIn48 + (TyApp happy_var_1 happy_var_2 + )}} + +happyReduce_118 = happySpecReduce_1 44# happyReduction_118 +happyReduction_118 happy_x_1 + = case happyOut49 happy_x_1 of { happy_var_1 -> + happyIn48 + (happy_var_1 + )} + +happyReduce_119 = happySpecReduce_1 45# happyReduction_119 +happyReduction_119 happy_x_1 + = case happyOut50 happy_x_1 of { happy_var_1 -> + happyIn49 + (TyCon happy_var_1 + )} + +happyReduce_120 = happySpecReduce_1 45# happyReduction_120 +happyReduction_120 happy_x_1 + = case happyOut181 happy_x_1 of { happy_var_1 -> + happyIn49 + (TyVar happy_var_1 + )} + +happyReduce_121 = happySpecReduce_3 45# happyReduction_121 +happyReduction_121 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut54 happy_x_2 of { happy_var_2 -> + happyIn49 + (TyTuple Boxed (reverse happy_var_2) + )} + +happyReduce_122 = happySpecReduce_3 45# happyReduction_122 +happyReduction_122 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut55 happy_x_2 of { happy_var_2 -> + happyIn49 + (TyTuple Unboxed (reverse happy_var_2) + )} + +happyReduce_123 = happySpecReduce_3 45# happyReduction_123 +happyReduction_123 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut47 happy_x_2 of { happy_var_2 -> + happyIn49 + (TyApp list_tycon happy_var_2 + )} + +happyReduce_124 = happySpecReduce_3 45# happyReduction_124 +happyReduction_124 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut52 happy_x_2 of { happy_var_2 -> + happyIn49 + (happy_var_2 + )} + +happyReduce_125 = happyReduce 5# 45# 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) + = case happyOut52 happy_x_2 of { happy_var_2 -> + case happyOut80 happy_x_4 of { happy_var_4 -> + happyIn49 + (TyKind happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_126 = happySpecReduce_1 46# happyReduction_126 +happyReduction_126 happy_x_1 + = case happyOut164 happy_x_1 of { happy_var_1 -> + happyIn50 + (happy_var_1 + )} + +happyReduce_127 = happySpecReduce_2 46# happyReduction_127 +happyReduction_127 happy_x_2 + happy_x_1 + = happyIn50 + (unit_tycon_name + ) + +happyReduce_128 = happySpecReduce_3 46# happyReduction_128 +happyReduction_128 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn50 + (fun_tycon_name + ) + +happyReduce_129 = happySpecReduce_2 46# happyReduction_129 +happyReduction_129 happy_x_2 + happy_x_1 + = happyIn50 + (list_tycon_name + ) + +happyReduce_130 = happySpecReduce_3 46# happyReduction_130 +happyReduction_130 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut112 happy_x_2 of { happy_var_2 -> + happyIn50 + (tuple_tycon_name happy_var_2 + )} + +happyReduce_131 = happySpecReduce_1 47# happyReduction_131 +happyReduction_131 happy_x_1 + = case happyOut155 happy_x_1 of { happy_var_1 -> + happyIn51 + (happy_var_1 + )} + +happyReduce_132 = happyReduce 4# 48# happyReduction_132 +happyReduction_132 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut56 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_4 of { happy_var_4 -> + happyIn52 + (mkTyForall (Just happy_var_2) [] happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_133 = happySpecReduce_3 48# happyReduction_133 +happyReduction_133 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut53 happy_x_1 of { happy_var_1 -> + case happyOut47 happy_x_3 of { happy_var_3 -> + happyIn52 + (mkTyForall Nothing happy_var_1 happy_var_3 + )}} + +happyReduce_134 = happySpecReduce_1 48# happyReduction_134 +happyReduction_134 happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + happyIn52 + (happy_var_1 + )} + +happyReduce_135 = happyMonadReduce 1# 49# happyReduction_135 +happyReduction_135 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut48 happy_x_1 of { happy_var_1 -> + ( checkContext happy_var_1)} + ) (\r -> happyReturn (happyIn53 r)) + +happyReduce_136 = happyMonadReduce 3# 49# happyReduction_136 +happyReduction_136 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut48 happy_x_3 of { happy_var_3 -> + ( checkContext (TyPred $ EqualP happy_var_1 happy_var_3))}} + ) (\r -> happyReturn (happyIn53 r)) + +happyReduce_137 = happySpecReduce_3 50# happyReduction_137 +happyReduction_137 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut55 happy_x_1 of { happy_var_1 -> + case happyOut47 happy_x_3 of { happy_var_3 -> + happyIn54 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_138 = happySpecReduce_1 51# happyReduction_138 +happyReduction_138 happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + happyIn55 + ([happy_var_1] + )} + +happyReduce_139 = happySpecReduce_3 51# happyReduction_139 +happyReduction_139 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut55 happy_x_1 of { happy_var_1 -> + case happyOut47 happy_x_3 of { happy_var_3 -> + happyIn55 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_140 = happySpecReduce_2 52# happyReduction_140 +happyReduction_140 happy_x_2 + happy_x_1 + = case happyOut56 happy_x_1 of { happy_var_1 -> + case happyOut57 happy_x_2 of { happy_var_2 -> + happyIn56 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_141 = happySpecReduce_0 52# happyReduction_141 +happyReduction_141 = happyIn56 + ([] + ) + +happyReduce_142 = happySpecReduce_1 53# happyReduction_142 +happyReduction_142 happy_x_1 + = case happyOut181 happy_x_1 of { happy_var_1 -> + happyIn57 + (UnkindedVar happy_var_1 + )} + +happyReduce_143 = happyReduce 5# 53# happyReduction_143 +happyReduction_143 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut181 happy_x_2 of { happy_var_2 -> + case happyOut80 happy_x_4 of { happy_var_4 -> + happyIn57 + (KindedVar happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_144 = happySpecReduce_2 54# happyReduction_144 +happyReduction_144 happy_x_2 + happy_x_1 + = case happyOut58 happy_x_1 of { happy_var_1 -> + case happyOut181 happy_x_2 of { happy_var_2 -> + happyIn58 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_145 = happySpecReduce_0 54# happyReduction_145 +happyReduction_145 = happyIn58 + ([] + ) + +happyReduce_146 = happySpecReduce_0 55# happyReduction_146 +happyReduction_146 = happyIn59 + ([] + ) + +happyReduce_147 = happySpecReduce_2 55# happyReduction_147 +happyReduction_147 happy_x_2 + happy_x_1 + = case happyOut60 happy_x_2 of { happy_var_2 -> + happyIn59 + (reverse happy_var_2 + )} + +happyReduce_148 = happySpecReduce_3 56# happyReduction_148 +happyReduction_148 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_149 = happySpecReduce_1 56# happyReduction_149 +happyReduction_149 happy_x_1 + = case happyOut61 happy_x_1 of { happy_var_1 -> + happyIn60 + ([happy_var_1] + )} + +happyReduce_150 = happySpecReduce_3 57# happyReduction_150 +happyReduction_150 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut58 happy_x_1 of { happy_var_1 -> + case happyOut58 happy_x_3 of { happy_var_3 -> + happyIn61 + (FunDep (reverse happy_var_1) (reverse happy_var_3) + )}} + +happyReduce_151 = happySpecReduce_3 58# happyReduction_151 +happyReduction_151 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut63 happy_x_2 of { happy_var_2 -> + happyIn62 + (happy_var_2 + )} + +happyReduce_152 = happySpecReduce_3 58# happyReduction_152 +happyReduction_152 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut63 happy_x_2 of { happy_var_2 -> + happyIn62 + (happy_var_2 + )} + +happyReduce_153 = happySpecReduce_3 59# happyReduction_153 +happyReduction_153 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut64 happy_x_2 of { happy_var_2 -> + happyIn63 + (happy_var_2 + )} + +happyReduce_154 = happySpecReduce_3 60# happyReduction_154 +happyReduction_154 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut64 happy_x_1 of { happy_var_1 -> + case happyOut65 happy_x_3 of { happy_var_3 -> + happyIn64 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_155 = happySpecReduce_1 60# happyReduction_155 +happyReduction_155 happy_x_1 + = case happyOut65 happy_x_1 of { happy_var_1 -> + happyIn64 + ([happy_var_1] + )} + +happyReduce_156 = happyMonadReduce 4# 61# happyReduction_156 +happyReduction_156 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut150 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_4 of { happy_var_4 -> + ( do { c <- checkUnQual happy_var_2; + return $ GadtDecl happy_var_1 c happy_var_4 })}}} + ) (\r -> happyReturn (happyIn65 r)) + +happyReduce_157 = happySpecReduce_0 62# happyReduction_157 +happyReduction_157 = happyIn66 + ([] + ) + +happyReduce_158 = happySpecReduce_2 62# happyReduction_158 +happyReduction_158 happy_x_2 + happy_x_1 + = case happyOut67 happy_x_2 of { happy_var_2 -> + happyIn66 + (happy_var_2 + )} + +happyReduce_159 = happySpecReduce_3 63# happyReduction_159 +happyReduction_159 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut67 happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_3 of { happy_var_3 -> + happyIn67 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_160 = happySpecReduce_1 63# happyReduction_160 +happyReduction_160 happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + happyIn67 + ([happy_var_1] + )} + +happyReduce_161 = happyReduce 5# 64# happyReduction_161 +happyReduction_161 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut69 happy_x_2 of { happy_var_2 -> + case happyOut53 happy_x_3 of { happy_var_3 -> + case happyOut70 happy_x_5 of { happy_var_5 -> + happyIn68 + (QualConDecl happy_var_1 happy_var_2 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}}} + +happyReduce_162 = happySpecReduce_3 64# happyReduction_162 +happyReduction_162 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut69 happy_x_2 of { happy_var_2 -> + case happyOut70 happy_x_3 of { happy_var_3 -> + happyIn68 + (QualConDecl happy_var_1 happy_var_2 [] happy_var_3 + )}}} + +happyReduce_163 = happySpecReduce_3 65# happyReduction_163 +happyReduction_163 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut56 happy_x_2 of { happy_var_2 -> + happyIn69 + (happy_var_2 + )} + +happyReduce_164 = happySpecReduce_0 65# happyReduction_164 +happyReduction_164 = happyIn69 + ([] + ) + +happyReduce_165 = happySpecReduce_1 66# happyReduction_165 +happyReduction_165 happy_x_1 + = case happyOut71 happy_x_1 of { happy_var_1 -> + happyIn70 + (ConDecl (fst happy_var_1) (snd happy_var_1) + )} + +happyReduce_166 = happySpecReduce_3 66# happyReduction_166 +happyReduction_166 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut74 happy_x_1 of { happy_var_1 -> + case happyOut154 happy_x_2 of { happy_var_2 -> + case happyOut74 happy_x_3 of { happy_var_3 -> + happyIn70 + (ConDecl happy_var_2 [happy_var_1,happy_var_3] + )}}} + +happyReduce_167 = happySpecReduce_3 66# happyReduction_167 +happyReduction_167 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut149 happy_x_1 of { happy_var_1 -> + happyIn70 + (RecDecl happy_var_1 [] + )} + +happyReduce_168 = happyReduce 4# 66# happyReduction_168 +happyReduction_168 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut149 happy_x_1 of { happy_var_1 -> + case happyOut75 happy_x_3 of { happy_var_3 -> + happyIn70 + (RecDecl happy_var_1 (reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_169 = happyMonadReduce 1# 67# happyReduction_169 +happyReduction_169 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut48 happy_x_1 of { happy_var_1 -> + ( do { (c,ts) <- splitTyConApp happy_var_1; + return (c,map UnBangedTy ts) })} + ) (\r -> happyReturn (happyIn71 r)) + +happyReduce_170 = happySpecReduce_1 67# happyReduction_170 +happyReduction_170 happy_x_1 + = case happyOut72 happy_x_1 of { happy_var_1 -> + happyIn71 + (happy_var_1 + )} + +happyReduce_171 = happyMonadReduce 3# 68# happyReduction_171 +happyReduction_171 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut49 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 (happyIn72 r)) + +happyReduce_172 = happySpecReduce_2 68# happyReduction_172 +happyReduction_172 happy_x_2 + happy_x_1 + = case happyOut72 happy_x_1 of { happy_var_1 -> + case happyOut73 happy_x_2 of { happy_var_2 -> + happyIn72 + ((fst happy_var_1, snd happy_var_1 ++ [happy_var_2] ) + )}} + +happyReduce_173 = happySpecReduce_1 69# happyReduction_173 +happyReduction_173 happy_x_1 + = case happyOut49 happy_x_1 of { happy_var_1 -> + happyIn73 + (UnBangedTy happy_var_1 + )} + +happyReduce_174 = happySpecReduce_2 69# happyReduction_174 +happyReduction_174 happy_x_2 + happy_x_1 + = case happyOut49 happy_x_2 of { happy_var_2 -> + happyIn73 + (BangedTy happy_var_2 + )} + +happyReduce_175 = happySpecReduce_1 70# happyReduction_175 +happyReduction_175 happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + happyIn74 + (UnBangedTy happy_var_1 + )} + +happyReduce_176 = happySpecReduce_2 70# happyReduction_176 +happyReduction_176 happy_x_2 + happy_x_1 + = case happyOut49 happy_x_2 of { happy_var_2 -> + happyIn74 + (BangedTy happy_var_2 + )} + +happyReduce_177 = happySpecReduce_3 71# happyReduction_177 +happyReduction_177 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut76 happy_x_3 of { happy_var_3 -> + happyIn75 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_178 = happySpecReduce_1 71# happyReduction_178 +happyReduction_178 happy_x_1 + = case happyOut76 happy_x_1 of { happy_var_1 -> + happyIn75 + ([happy_var_1] + )} + +happyReduce_179 = happySpecReduce_3 72# happyReduction_179 +happyReduction_179 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut42 happy_x_1 of { happy_var_1 -> + case happyOut77 happy_x_3 of { happy_var_3 -> + happyIn76 + ((reverse happy_var_1, happy_var_3) + )}} + +happyReduce_180 = happySpecReduce_1 73# happyReduction_180 +happyReduction_180 happy_x_1 + = case happyOut52 happy_x_1 of { happy_var_1 -> + happyIn77 + (UnBangedTy happy_var_1 + )} + +happyReduce_181 = happySpecReduce_2 73# happyReduction_181 +happyReduction_181 happy_x_2 + happy_x_1 + = case happyOut49 happy_x_2 of { happy_var_2 -> + happyIn77 + (BangedTy happy_var_2 + )} + +happyReduce_182 = happySpecReduce_0 74# happyReduction_182 +happyReduction_182 = happyIn78 + ([] + ) + +happyReduce_183 = happySpecReduce_2 74# happyReduction_183 +happyReduction_183 happy_x_2 + happy_x_1 + = case happyOut180 happy_x_2 of { happy_var_2 -> + happyIn78 + ([happy_var_2] + )} + +happyReduce_184 = happySpecReduce_3 74# happyReduction_184 +happyReduction_184 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn78 + ([] + ) + +happyReduce_185 = happyReduce 4# 74# happyReduction_185 +happyReduction_185 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut79 happy_x_3 of { happy_var_3 -> + happyIn78 + (reverse happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_186 = happySpecReduce_3 75# happyReduction_186 +happyReduction_186 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut79 happy_x_1 of { happy_var_1 -> + case happyOut180 happy_x_3 of { happy_var_3 -> + happyIn79 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_187 = happySpecReduce_1 75# happyReduction_187 +happyReduction_187 happy_x_1 + = case happyOut180 happy_x_1 of { happy_var_1 -> + happyIn79 + ([happy_var_1] + )} + +happyReduce_188 = happySpecReduce_1 76# happyReduction_188 +happyReduction_188 happy_x_1 + = case happyOut81 happy_x_1 of { happy_var_1 -> + happyIn80 + (happy_var_1 + )} + +happyReduce_189 = happySpecReduce_3 76# happyReduction_189 +happyReduction_189 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut81 happy_x_1 of { happy_var_1 -> + case happyOut80 happy_x_3 of { happy_var_3 -> + happyIn80 + (KindFn happy_var_1 happy_var_3 + )}} + +happyReduce_190 = happySpecReduce_1 77# happyReduction_190 +happyReduction_190 happy_x_1 + = happyIn81 + (KindStar + ) + +happyReduce_191 = happySpecReduce_1 77# happyReduction_191 +happyReduction_191 happy_x_1 + = happyIn81 + (KindBang + ) + +happyReduce_192 = happySpecReduce_3 77# happyReduction_192 +happyReduction_192 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut80 happy_x_2 of { happy_var_2 -> + happyIn81 + (happy_var_2 + )} + +happyReduce_193 = happySpecReduce_0 78# happyReduction_193 +happyReduction_193 = happyIn82 + (Nothing + ) + +happyReduce_194 = happySpecReduce_2 78# happyReduction_194 +happyReduction_194 happy_x_2 + happy_x_1 + = case happyOut80 happy_x_2 of { happy_var_2 -> + happyIn82 + (Just happy_var_2 + )} + +happyReduce_195 = happyMonadReduce 2# 79# happyReduction_195 +happyReduction_195 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut84 happy_x_2 of { happy_var_2 -> + ( checkClassBody happy_var_2)} + ) (\r -> happyReturn (happyIn83 r)) + +happyReduce_196 = happySpecReduce_0 79# happyReduction_196 +happyReduction_196 = happyIn83 + ([] + ) + +happyReduce_197 = happySpecReduce_3 80# happyReduction_197 +happyReduction_197 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut85 happy_x_2 of { happy_var_2 -> + happyIn84 + (happy_var_2 + )} + +happyReduce_198 = happySpecReduce_3 80# happyReduction_198 +happyReduction_198 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut85 happy_x_2 of { happy_var_2 -> + happyIn84 + (happy_var_2 + )} + +happyReduce_199 = happyMonadReduce 3# 81# happyReduction_199 +happyReduction_199 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut86 happy_x_2 of { happy_var_2 -> + ( checkRevClsDecls happy_var_2)} + ) (\r -> happyReturn (happyIn85 r)) + +happyReduce_200 = happySpecReduce_1 81# happyReduction_200 +happyReduction_200 happy_x_1 + = happyIn85 + ([] + ) + +happyReduce_201 = happySpecReduce_3 82# happyReduction_201 +happyReduction_201 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut86 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_3 of { happy_var_3 -> + happyIn86 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_202 = happySpecReduce_1 82# happyReduction_202 +happyReduction_202 happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + happyIn86 + ([happy_var_1] + )} + +happyReduce_203 = happySpecReduce_1 83# happyReduction_203 +happyReduction_203 happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + happyIn87 + (ClsDecl happy_var_1 + )} + +happyReduce_204 = happySpecReduce_1 83# happyReduction_204 +happyReduction_204 happy_x_1 + = case happyOut88 happy_x_1 of { happy_var_1 -> + happyIn87 + (happy_var_1 + )} + +happyReduce_205 = happyMonadReduce 4# 84# happyReduction_205 +happyReduction_205 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut47 happy_x_3 of { happy_var_3 -> + case happyOut82 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 (happyIn88 r)) + +happyReduce_206 = happyReduce 5# 84# happyReduction_206 +happyReduction_206 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + case happyOut52 happy_x_5 of { happy_var_5 -> + happyIn88 + (ClsTyDef happy_var_1 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_207 = happyMonadReduce 4# 84# happyReduction_207 +happyReduction_207 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut52 happy_x_3 of { happy_var_3 -> + case happyOut82 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 (happyIn88 r)) + +happyReduce_208 = happyMonadReduce 4# 85# happyReduction_208 +happyReduction_208 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut90 happy_x_3 of { happy_var_3 -> + ( checkInstBody happy_var_3)} + ) (\r -> happyReturn (happyIn89 r)) + +happyReduce_209 = happyMonadReduce 4# 85# happyReduction_209 +happyReduction_209 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut90 happy_x_3 of { happy_var_3 -> + ( checkInstBody happy_var_3)} + ) (\r -> happyReturn (happyIn89 r)) + +happyReduce_210 = happySpecReduce_0 85# happyReduction_210 +happyReduction_210 = happyIn89 + ([] + ) + +happyReduce_211 = happyMonadReduce 3# 86# happyReduction_211 +happyReduction_211 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut91 happy_x_2 of { happy_var_2 -> + ( checkRevInstDecls happy_var_2)} + ) (\r -> happyReturn (happyIn90 r)) + +happyReduce_212 = happySpecReduce_1 86# happyReduction_212 +happyReduction_212 happy_x_1 + = happyIn90 + ([] + ) + +happyReduce_213 = happySpecReduce_3 87# happyReduction_213 +happyReduction_213 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut91 happy_x_1 of { happy_var_1 -> + case happyOut92 happy_x_3 of { happy_var_3 -> + happyIn91 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_214 = happySpecReduce_1 87# happyReduction_214 +happyReduction_214 happy_x_1 + = case happyOut92 happy_x_1 of { happy_var_1 -> + happyIn91 + ([happy_var_1] + )} + +happyReduce_215 = happySpecReduce_1 88# happyReduction_215 +happyReduction_215 happy_x_1 + = case happyOut94 happy_x_1 of { happy_var_1 -> + happyIn92 + (InsDecl happy_var_1 + )} + +happyReduce_216 = happySpecReduce_1 88# happyReduction_216 +happyReduction_216 happy_x_1 + = case happyOut93 happy_x_1 of { happy_var_1 -> + happyIn92 + (happy_var_1 + )} + +happyReduce_217 = happyMonadReduce 5# 89# happyReduction_217 +happyReduction_217 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut52 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 (happyIn93 r)) + +happyReduce_218 = happyMonadReduce 5# 89# happyReduction_218 +happyReduction_218 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut34 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_3 of { happy_var_3 -> + case happyOut66 happy_x_4 of { happy_var_4 -> + case happyOut78 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 (happyIn93 r)) + +happyReduce_219 = happyMonadReduce 6# 89# happyReduction_219 +happyReduction_219 (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 happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut34 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_3 of { happy_var_3 -> + case happyOut82 happy_x_4 of { happy_var_4 -> + case happyOut62 happy_x_6 of { happy_var_6 -> + ( 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)) })}}}}} + ) (\r -> happyReturn (happyIn93 r)) + +happyReduce_220 = happyMonadReduce 4# 90# happyReduction_220 +happyReduction_220 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut103 happy_x_2 of { happy_var_2 -> + case happyOut96 happy_x_3 of { happy_var_3 -> + case happyOut95 happy_x_4 of { happy_var_4 -> + ( checkValDef happy_var_1 happy_var_2 happy_var_3 happy_var_4)}}}} + ) (\r -> happyReturn (happyIn94 r)) + +happyReduce_221 = happySpecReduce_2 91# happyReduction_221 +happyReduction_221 happy_x_2 + happy_x_1 + = case happyOut41 happy_x_2 of { happy_var_2 -> + happyIn95 + (happy_var_2 + )} + +happyReduce_222 = happySpecReduce_0 91# happyReduction_222 +happyReduction_222 = happyIn95 + (BDecls [] + ) + +happyReduce_223 = happySpecReduce_2 92# happyReduction_223 +happyReduction_223 happy_x_2 + happy_x_1 + = case happyOut99 happy_x_2 of { happy_var_2 -> + happyIn96 + (UnGuardedRhs happy_var_2 + )} + +happyReduce_224 = happySpecReduce_1 92# happyReduction_224 +happyReduction_224 happy_x_1 + = case happyOut97 happy_x_1 of { happy_var_1 -> + happyIn96 + (GuardedRhss (reverse happy_var_1) + )} + +happyReduce_225 = happySpecReduce_2 93# happyReduction_225 +happyReduction_225 happy_x_2 + happy_x_1 + = case happyOut97 happy_x_1 of { happy_var_1 -> + case happyOut98 happy_x_2 of { happy_var_2 -> + happyIn97 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_226 = happySpecReduce_1 93# happyReduction_226 +happyReduction_226 happy_x_1 + = case happyOut98 happy_x_1 of { happy_var_1 -> + happyIn97 + ([happy_var_1] + )} + +happyReduce_227 = happyReduce 5# 94# happyReduction_227 +happyReduction_227 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_3 of { happy_var_3 -> + case happyOut99 happy_x_5 of { happy_var_5 -> + happyIn98 + (GuardedRhs happy_var_1 (reverse happy_var_3) happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_228 = happyMonadReduce 1# 95# happyReduction_228 +happyReduction_228 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut100 happy_x_1 of { happy_var_1 -> + ( checkExpr happy_var_1)} + ) (\r -> happyReturn (happyIn99 r)) + +happyReduce_229 = happyReduce 4# 96# happyReduction_229 +happyReduction_229 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut103 happy_x_1 of { happy_var_1 -> + case happyOut174 happy_x_3 of { happy_var_3 -> + case happyOut52 happy_x_4 of { happy_var_4 -> + happyIn100 + (ExpTypeSig happy_var_3 happy_var_1 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_230 = happySpecReduce_1 96# happyReduction_230 +happyReduction_230 happy_x_1 + = case happyOut101 happy_x_1 of { happy_var_1 -> + happyIn100 + (happy_var_1 + )} + +happyReduce_231 = happySpecReduce_2 96# happyReduction_231 +happyReduction_231 happy_x_2 + happy_x_1 + = case happyOut103 happy_x_1 of { happy_var_1 -> + case happyOut157 happy_x_2 of { happy_var_2 -> + happyIn100 + (PostOp happy_var_1 happy_var_2 + )}} + +happyReduce_232 = happySpecReduce_1 97# happyReduction_232 +happyReduction_232 happy_x_1 + = case happyOut102 happy_x_1 of { happy_var_1 -> + happyIn101 + (happy_var_1 + )} + +happyReduce_233 = happySpecReduce_1 97# happyReduction_233 +happyReduction_233 happy_x_1 + = case happyOut103 happy_x_1 of { happy_var_1 -> + happyIn101 + (happy_var_1 + )} + +happyReduce_234 = happySpecReduce_3 98# happyReduction_234 +happyReduction_234 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut103 happy_x_1 of { happy_var_1 -> + case happyOut157 happy_x_2 of { happy_var_2 -> + case happyOut104 happy_x_3 of { happy_var_3 -> + happyIn102 + (InfixApp happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_235 = happySpecReduce_1 98# happyReduction_235 +happyReduction_235 happy_x_1 + = case happyOut104 happy_x_1 of { happy_var_1 -> + happyIn102 + (happy_var_1 + )} + +happyReduce_236 = happySpecReduce_3 99# happyReduction_236 +happyReduction_236 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut103 happy_x_1 of { happy_var_1 -> + case happyOut157 happy_x_2 of { happy_var_2 -> + case happyOut105 happy_x_3 of { happy_var_3 -> + happyIn103 + (InfixApp happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_237 = happySpecReduce_1 99# happyReduction_237 +happyReduction_237 happy_x_1 + = case happyOut124 happy_x_1 of { happy_var_1 -> + happyIn103 + (happy_var_1 + )} + +happyReduce_238 = happySpecReduce_1 99# happyReduction_238 +happyReduction_238 happy_x_1 + = case happyOut105 happy_x_1 of { happy_var_1 -> + happyIn103 + (happy_var_1 + )} + +happyReduce_239 = happyReduce 5# 100# happyReduction_239 +happyReduction_239 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_2 of { happy_var_2 -> + case happyOut107 happy_x_3 of { happy_var_3 -> + case happyOut100 happy_x_5 of { happy_var_5 -> + happyIn104 + (Lambda happy_var_2 (reverse happy_var_3) happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_240 = happyReduce 4# 100# happyReduction_240 +happyReduction_240 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut41 happy_x_2 of { happy_var_2 -> + case happyOut100 happy_x_4 of { happy_var_4 -> + happyIn104 + (Let happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_241 = happyReduce 6# 100# happyReduction_241 +happyReduction_241 (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 happyOut100 happy_x_2 of { happy_var_2 -> + case happyOut100 happy_x_4 of { happy_var_4 -> + case happyOut100 happy_x_6 of { happy_var_6 -> + happyIn104 + (If happy_var_2 happy_var_4 happy_var_6 + ) `HappyStk` happyRest}}} + +happyReduce_242 = happyReduce 4# 101# happyReduction_242 +happyReduction_242 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut100 happy_x_2 of { happy_var_2 -> + case happyOut129 happy_x_4 of { happy_var_4 -> + happyIn105 + (Case happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_243 = happySpecReduce_2 101# happyReduction_243 +happyReduction_243 happy_x_2 + happy_x_1 + = case happyOut106 happy_x_2 of { happy_var_2 -> + happyIn105 + (NegApp happy_var_2 + )} + +happyReduce_244 = happySpecReduce_2 101# happyReduction_244 +happyReduction_244 happy_x_2 + happy_x_1 + = case happyOut137 happy_x_2 of { happy_var_2 -> + happyIn105 + (Do happy_var_2 + )} + +happyReduce_245 = happySpecReduce_2 101# happyReduction_245 +happyReduction_245 happy_x_2 + happy_x_1 + = case happyOut137 happy_x_2 of { happy_var_2 -> + happyIn105 + (MDo happy_var_2 + )} + +happyReduce_246 = happySpecReduce_1 101# happyReduction_246 +happyReduction_246 happy_x_1 + = case happyOut106 happy_x_1 of { happy_var_1 -> + happyIn105 + (happy_var_1 + )} + +happyReduce_247 = happySpecReduce_2 102# happyReduction_247 +happyReduction_247 happy_x_2 + happy_x_1 + = case happyOut106 happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_2 of { happy_var_2 -> + happyIn106 + (App happy_var_1 happy_var_2 + )}} + +happyReduce_248 = happySpecReduce_1 102# happyReduction_248 +happyReduction_248 happy_x_1 + = case happyOut109 happy_x_1 of { happy_var_1 -> + happyIn106 + (happy_var_1 + )} + +happyReduce_249 = happySpecReduce_2 103# happyReduction_249 +happyReduction_249 happy_x_2 + happy_x_1 + = case happyOut107 happy_x_1 of { happy_var_1 -> + case happyOut108 happy_x_2 of { happy_var_2 -> + happyIn107 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_250 = happySpecReduce_1 103# happyReduction_250 +happyReduction_250 happy_x_1 + = case happyOut108 happy_x_1 of { happy_var_1 -> + happyIn107 + ([happy_var_1] + )} + +happyReduce_251 = happyMonadReduce 1# 104# happyReduction_251 +happyReduction_251 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut109 happy_x_1 of { happy_var_1 -> + ( checkPattern happy_var_1)} + ) (\r -> happyReturn (happyIn108 r)) + +happyReduce_252 = happyMonadReduce 3# 105# happyReduction_252 +happyReduction_252 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut147 happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_3 of { happy_var_3 -> + ( do { n <- checkUnQual happy_var_1; + return (AsPat n happy_var_3) })}} + ) (\r -> happyReturn (happyIn109 r)) + +happyReduce_253 = happyMonadReduce 3# 105# happyReduction_253 +happyReduction_253 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut147 happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_3 of { happy_var_3 -> + ( do { n <- checkUnQual happy_var_1; + return (CAsRP n happy_var_3) })}} + ) (\r -> happyReturn (happyIn109 r)) + +happyReduce_254 = happySpecReduce_2 105# happyReduction_254 +happyReduction_254 happy_x_2 + happy_x_1 + = case happyOut109 happy_x_2 of { happy_var_2 -> + happyIn109 + (IrrPat happy_var_2 + )} + +happyReduce_255 = happySpecReduce_1 105# happyReduction_255 +happyReduction_255 happy_x_1 + = case happyOut110 happy_x_1 of { happy_var_1 -> + happyIn109 + (happy_var_1 + )} + +happyReduce_256 = happyMonadReduce 3# 106# happyReduction_256 +happyReduction_256 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut110 happy_x_1 of { happy_var_1 -> + ( mkRecConstrOrUpdate happy_var_1 [])} + ) (\r -> happyReturn (happyIn110 r)) + +happyReduce_257 = happyMonadReduce 4# 106# happyReduction_257 +happyReduction_257 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut110 happy_x_1 of { happy_var_1 -> + case happyOut139 happy_x_3 of { happy_var_3 -> + ( mkRecConstrOrUpdate happy_var_1 (reverse happy_var_3))}} + ) (\r -> happyReturn (happyIn110 r)) + +happyReduce_258 = happySpecReduce_1 106# happyReduction_258 +happyReduction_258 happy_x_1 + = case happyOut111 happy_x_1 of { happy_var_1 -> + happyIn110 + (happy_var_1 + )} + +happyReduce_259 = happySpecReduce_1 107# happyReduction_259 +happyReduction_259 happy_x_1 + = case happyOut148 happy_x_1 of { happy_var_1 -> + happyIn111 + (IPVar happy_var_1 + )} + +happyReduce_260 = happySpecReduce_1 107# happyReduction_260 +happyReduction_260 happy_x_1 + = case happyOut147 happy_x_1 of { happy_var_1 -> + happyIn111 + (Var happy_var_1 + )} + +happyReduce_261 = happySpecReduce_1 107# happyReduction_261 +happyReduction_261 happy_x_1 + = case happyOut144 happy_x_1 of { happy_var_1 -> + happyIn111 + (happy_var_1 + )} + +happyReduce_262 = happySpecReduce_1 107# happyReduction_262 +happyReduction_262 happy_x_1 + = case happyOut173 happy_x_1 of { happy_var_1 -> + happyIn111 + (Lit happy_var_1 + )} + +happyReduce_263 = happySpecReduce_3 107# happyReduction_263 +happyReduction_263 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut100 happy_x_2 of { happy_var_2 -> + happyIn111 + (Paren happy_var_2 + )} + +happyReduce_264 = happySpecReduce_3 107# happyReduction_264 +happyReduction_264 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut113 happy_x_2 of { happy_var_2 -> + happyIn111 + (Tuple (reverse happy_var_2) + )} + +happyReduce_265 = happySpecReduce_3 107# happyReduction_265 +happyReduction_265 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut125 happy_x_2 of { happy_var_2 -> + happyIn111 + (happy_var_2 + )} + +happyReduce_266 = happyReduce 4# 107# happyReduction_266 +happyReduction_266 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut158 happy_x_2 of { happy_var_2 -> + case happyOut101 happy_x_3 of { happy_var_3 -> + happyIn111 + (RightSection happy_var_2 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_267 = happySpecReduce_1 107# happyReduction_267 +happyReduction_267 happy_x_1 + = happyIn111 + (WildCard + ) + +happyReduce_268 = happySpecReduce_3 107# happyReduction_268 +happyReduction_268 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut115 happy_x_2 of { happy_var_2 -> + happyIn111 + (happy_var_2 + )} + +happyReduce_269 = happySpecReduce_3 107# happyReduction_269 +happyReduction_269 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut114 happy_x_2 of { happy_var_2 -> + happyIn111 + (SeqRP $ reverse happy_var_2 + )} + +happyReduce_270 = happyReduce 5# 107# happyReduction_270 +happyReduction_270 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut100 happy_x_2 of { happy_var_2 -> + case happyOut127 happy_x_4 of { happy_var_4 -> + happyIn111 + (GuardRP happy_var_2 $ reverse happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_271 = happySpecReduce_1 107# happyReduction_271 +happyReduction_271 happy_x_1 + = case happyOut116 happy_x_1 of { happy_var_1 -> + happyIn111 + (happy_var_1 + )} + +happyReduce_272 = happySpecReduce_1 107# happyReduction_272 +happyReduction_272 happy_x_1 + = case happyOutTok happy_x_1 of { (THIdEscape happy_var_1) -> + happyIn111 + (SpliceExp $ IdSplice happy_var_1 + )} + +happyReduce_273 = happySpecReduce_3 107# happyReduction_273 +happyReduction_273 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut99 happy_x_2 of { happy_var_2 -> + happyIn111 + (SpliceExp $ ParenSplice happy_var_2 + )} + +happyReduce_274 = happySpecReduce_3 107# happyReduction_274 +happyReduction_274 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut99 happy_x_2 of { happy_var_2 -> + happyIn111 + (BracketExp $ ExpBracket happy_var_2 + )} + +happyReduce_275 = happyMonadReduce 3# 107# happyReduction_275 +happyReduction_275 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut101 happy_x_2 of { happy_var_2 -> + ( do { p <- checkPattern happy_var_2; + return $ BracketExp $ PatBracket p })} + ) (\r -> happyReturn (happyIn111 r)) + +happyReduce_276 = happySpecReduce_3 107# happyReduction_276 +happyReduction_276 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut52 happy_x_2 of { happy_var_2 -> + happyIn111 + (BracketExp $ TypeBracket happy_var_2 + )} + +happyReduce_277 = happyReduce 5# 107# happyReduction_277 +happyReduction_277 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut31 happy_x_3 of { happy_var_3 -> + happyIn111 + (BracketExp $ DeclBracket happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_278 = happySpecReduce_2 107# happyReduction_278 +happyReduction_278 happy_x_2 + happy_x_1 + = case happyOut147 happy_x_2 of { happy_var_2 -> + happyIn111 + (VarQuote happy_var_2 + )} + +happyReduce_279 = happySpecReduce_2 107# happyReduction_279 +happyReduction_279 happy_x_2 + happy_x_1 + = case happyOut150 happy_x_2 of { happy_var_2 -> + happyIn111 + (VarQuote happy_var_2 + )} + +happyReduce_280 = happySpecReduce_2 107# happyReduction_280 +happyReduction_280 happy_x_2 + happy_x_1 + = case happyOut181 happy_x_2 of { happy_var_2 -> + happyIn111 + (TypQuote (UnQual happy_var_2) + )} + +happyReduce_281 = happySpecReduce_2 107# happyReduction_281 +happyReduction_281 happy_x_2 + happy_x_1 + = case happyOut50 happy_x_2 of { happy_var_2 -> + happyIn111 + (TypQuote happy_var_2 + )} + +happyReduce_282 = happySpecReduce_2 108# happyReduction_282 +happyReduction_282 happy_x_2 + happy_x_1 + = case happyOut112 happy_x_1 of { happy_var_1 -> + happyIn112 + (happy_var_1 + 1 + )} + +happyReduce_283 = happySpecReduce_1 108# happyReduction_283 +happyReduction_283 happy_x_1 + = happyIn112 + (1 + ) + +happyReduce_284 = happySpecReduce_3 109# happyReduction_284 +happyReduction_284 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut113 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + happyIn113 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_285 = happySpecReduce_3 109# happyReduction_285 +happyReduction_285 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + happyIn113 + ([happy_var_3,happy_var_1] + )}} + +happyReduce_286 = happySpecReduce_3 110# happyReduction_286 +happyReduction_286 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut114 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + happyIn114 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_287 = happySpecReduce_1 110# happyReduction_287 +happyReduction_287 happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + happyIn114 + ([happy_var_1] + )} + +happyReduce_288 = happySpecReduce_3 111# happyReduction_288 +happyReduction_288 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + case happyOut115 happy_x_3 of { happy_var_3 -> + happyIn115 + (EitherRP happy_var_1 happy_var_3 + )}} + +happyReduce_289 = happySpecReduce_3 111# happyReduction_289 +happyReduction_289 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + happyIn115 + (EitherRP happy_var_1 happy_var_3 + )}} + +happyReduce_290 = happyMonadReduce 10# 112# happyReduction_290 +happyReduction_290 (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 happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut119 happy_x_3 of { happy_var_3 -> + case happyOut121 happy_x_4 of { happy_var_4 -> + case happyOut123 happy_x_5 of { happy_var_5 -> + case happyOut117 happy_x_7 of { happy_var_7 -> + case happyOut119 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 (happyIn116 r)) + +happyReduce_291 = happyReduce 6# 112# happyReduction_291 +happyReduction_291 (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 happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut119 happy_x_3 of { happy_var_3 -> + case happyOut121 happy_x_4 of { happy_var_4 -> + case happyOut123 happy_x_5 of { happy_var_5 -> + happyIn116 + (XETag happy_var_1 happy_var_3 (reverse happy_var_4) happy_var_5 + ) `HappyStk` happyRest}}}} + +happyReduce_292 = happySpecReduce_3 112# happyReduction_292 +happyReduction_292 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut100 happy_x_2 of { happy_var_2 -> + happyIn116 + (XExpTag happy_var_2 + )} + +happyReduce_293 = happySpecReduce_2 113# happyReduction_293 +happyReduction_293 happy_x_2 + happy_x_1 + = case happyOut117 happy_x_1 of { happy_var_1 -> + case happyOut118 happy_x_2 of { happy_var_2 -> + happyIn117 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_294 = happySpecReduce_0 113# happyReduction_294 +happyReduction_294 = happyIn117 + ([] + ) + +happyReduce_295 = happySpecReduce_1 114# happyReduction_295 +happyReduction_295 happy_x_1 + = case happyOutTok happy_x_1 of { (XPCDATA happy_var_1) -> + happyIn118 + (XPcdata happy_var_1 + )} + +happyReduce_296 = happySpecReduce_3 114# happyReduction_296 +happyReduction_296 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut114 happy_x_2 of { happy_var_2 -> + happyIn118 + (XRPats $ reverse happy_var_2 + )} + +happyReduce_297 = happySpecReduce_1 114# happyReduction_297 +happyReduction_297 happy_x_1 + = case happyOut116 happy_x_1 of { happy_var_1 -> + happyIn118 + (happy_var_1 + )} + +happyReduce_298 = happySpecReduce_3 115# happyReduction_298 +happyReduction_298 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut120 happy_x_1 of { happy_var_1 -> + case happyOut120 happy_x_3 of { happy_var_3 -> + happyIn119 + (XDomName happy_var_1 happy_var_3 + )}} + +happyReduce_299 = happySpecReduce_1 115# happyReduction_299 +happyReduction_299 happy_x_1 + = case happyOut120 happy_x_1 of { happy_var_1 -> + happyIn119 + (XName happy_var_1 + )} + +happyReduce_300 = happySpecReduce_1 116# happyReduction_300 +happyReduction_300 happy_x_1 + = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> + happyIn120 + (happy_var_1 + )} + +happyReduce_301 = happySpecReduce_1 116# happyReduction_301 +happyReduction_301 happy_x_1 + = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> + happyIn120 + (happy_var_1 + )} + +happyReduce_302 = happySpecReduce_1 116# happyReduction_302 +happyReduction_302 happy_x_1 + = case happyOutTok happy_x_1 of { (DVarId happy_var_1) -> + happyIn120 + (mkDVar happy_var_1 + )} + +happyReduce_303 = happySpecReduce_1 116# happyReduction_303 +happyReduction_303 happy_x_1 + = happyIn120 + ("type" + ) + +happyReduce_304 = happySpecReduce_1 116# happyReduction_304 +happyReduction_304 happy_x_1 + = happyIn120 + ("class" + ) + +happyReduce_305 = happySpecReduce_2 117# happyReduction_305 +happyReduction_305 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_306 = happySpecReduce_0 117# happyReduction_306 +happyReduction_306 = happyIn121 + ([] + ) + +happyReduce_307 = happySpecReduce_3 118# happyReduction_307 +happyReduction_307 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut119 happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_3 of { happy_var_3 -> + happyIn122 + (XAttr happy_var_1 happy_var_3 + )}} + +happyReduce_308 = happySpecReduce_1 119# happyReduction_308 +happyReduction_308 happy_x_1 + = case happyOut109 happy_x_1 of { happy_var_1 -> + happyIn123 + (Just happy_var_1 + )} + +happyReduce_309 = happySpecReduce_0 119# happyReduction_309 +happyReduction_309 = happyIn123 + (Nothing + ) + +happyReduce_310 = happySpecReduce_1 120# happyReduction_310 +happyReduction_310 happy_x_1 + = case happyOutTok happy_x_1 of { (DVarId happy_var_1) -> + happyIn124 + (mkDVarExpr happy_var_1 + )} + +happyReduce_311 = happySpecReduce_1 121# happyReduction_311 +happyReduction_311 happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + happyIn125 + (List [happy_var_1] + )} + +happyReduce_312 = happySpecReduce_1 121# happyReduction_312 +happyReduction_312 happy_x_1 + = case happyOut126 happy_x_1 of { happy_var_1 -> + happyIn125 + (List (reverse happy_var_1) + )} + +happyReduce_313 = happySpecReduce_2 121# happyReduction_313 +happyReduction_313 happy_x_2 + happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + happyIn125 + (EnumFrom happy_var_1 + )} + +happyReduce_314 = happyReduce 4# 121# happyReduction_314 +happyReduction_314 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut100 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + happyIn125 + (EnumFromThen happy_var_1 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_315 = happySpecReduce_3 121# happyReduction_315 +happyReduction_315 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + happyIn125 + (EnumFromTo happy_var_1 happy_var_3 + )}} + +happyReduce_316 = happyReduce 5# 121# happyReduction_316 +happyReduction_316 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut100 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + case happyOut100 happy_x_5 of { happy_var_5 -> + happyIn125 + (EnumFromThenTo happy_var_1 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_317 = happySpecReduce_3 121# happyReduction_317 +happyReduction_317 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_3 of { happy_var_3 -> + happyIn125 + (ListComp happy_var_1 (reverse happy_var_3) + )}} + +happyReduce_318 = happySpecReduce_3 122# happyReduction_318 +happyReduction_318 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut126 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + happyIn126 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_319 = happySpecReduce_3 122# happyReduction_319 +happyReduction_319 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + happyIn126 + ([happy_var_3,happy_var_1] + )}} + +happyReduce_320 = happySpecReduce_3 123# happyReduction_320 +happyReduction_320 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_3 of { happy_var_3 -> + happyIn127 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_321 = happySpecReduce_1 123# happyReduction_321 +happyReduction_321 happy_x_1 + = case happyOut128 happy_x_1 of { happy_var_1 -> + happyIn127 + ([happy_var_1] + )} + +happyReduce_322 = happyReduce 4# 124# happyReduction_322 +happyReduction_322 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut136 happy_x_1 of { happy_var_1 -> + case happyOut174 happy_x_2 of { happy_var_2 -> + case happyOut99 happy_x_4 of { happy_var_4 -> + happyIn128 + (Generator happy_var_2 happy_var_1 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_323 = happySpecReduce_1 124# happyReduction_323 +happyReduction_323 happy_x_1 + = case happyOut99 happy_x_1 of { happy_var_1 -> + happyIn128 + (Qualifier happy_var_1 + )} + +happyReduce_324 = happySpecReduce_2 124# happyReduction_324 +happyReduction_324 happy_x_2 + happy_x_1 + = case happyOut41 happy_x_2 of { happy_var_2 -> + happyIn128 + (LetStmt happy_var_2 + )} + +happyReduce_325 = happySpecReduce_3 125# happyReduction_325 +happyReduction_325 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut130 happy_x_2 of { happy_var_2 -> + happyIn129 + (happy_var_2 + )} + +happyReduce_326 = happySpecReduce_3 125# happyReduction_326 +happyReduction_326 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut130 happy_x_2 of { happy_var_2 -> + happyIn129 + (happy_var_2 + )} + +happyReduce_327 = happySpecReduce_3 126# happyReduction_327 +happyReduction_327 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut131 happy_x_2 of { happy_var_2 -> + happyIn130 + (reverse happy_var_2 + )} + +happyReduce_328 = happySpecReduce_3 127# happyReduction_328 +happyReduction_328 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut131 happy_x_1 of { happy_var_1 -> + case happyOut132 happy_x_3 of { happy_var_3 -> + happyIn131 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_329 = happySpecReduce_1 127# happyReduction_329 +happyReduction_329 happy_x_1 + = case happyOut132 happy_x_1 of { happy_var_1 -> + happyIn131 + ([happy_var_1] + )} + +happyReduce_330 = happyReduce 4# 128# happyReduction_330 +happyReduction_330 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut136 happy_x_2 of { happy_var_2 -> + case happyOut133 happy_x_3 of { happy_var_3 -> + case happyOut95 happy_x_4 of { happy_var_4 -> + happyIn132 + (Alt happy_var_1 happy_var_2 happy_var_3 happy_var_4 + ) `HappyStk` happyRest}}}} + +happyReduce_331 = happySpecReduce_2 129# happyReduction_331 +happyReduction_331 happy_x_2 + happy_x_1 + = case happyOut99 happy_x_2 of { happy_var_2 -> + happyIn133 + (UnGuardedAlt happy_var_2 + )} + +happyReduce_332 = happySpecReduce_1 129# happyReduction_332 +happyReduction_332 happy_x_1 + = case happyOut134 happy_x_1 of { happy_var_1 -> + happyIn133 + (GuardedAlts (reverse happy_var_1) + )} + +happyReduce_333 = happySpecReduce_2 130# happyReduction_333 +happyReduction_333 happy_x_2 + happy_x_1 + = case happyOut134 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_2 of { happy_var_2 -> + happyIn134 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_334 = happySpecReduce_1 130# happyReduction_334 +happyReduction_334 happy_x_1 + = case happyOut135 happy_x_1 of { happy_var_1 -> + happyIn134 + ([happy_var_1] + )} + +happyReduce_335 = happyReduce 5# 131# happyReduction_335 +happyReduction_335 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_3 of { happy_var_3 -> + case happyOut99 happy_x_5 of { happy_var_5 -> + happyIn135 + (GuardedAlt happy_var_1 (reverse happy_var_3) happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_336 = happyMonadReduce 1# 132# happyReduction_336 +happyReduction_336 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut103 happy_x_1 of { happy_var_1 -> + ( checkPattern happy_var_1)} + ) (\r -> happyReturn (happyIn136 r)) + +happyReduce_337 = happySpecReduce_3 133# happyReduction_337 +happyReduction_337 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut138 happy_x_2 of { happy_var_2 -> + happyIn137 + (happy_var_2 + )} + +happyReduce_338 = happySpecReduce_3 133# happyReduction_338 +happyReduction_338 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut138 happy_x_2 of { happy_var_2 -> + happyIn137 + (happy_var_2 + )} + +happyReduce_339 = happyReduce 4# 134# happyReduction_339 +happyReduction_339 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut41 happy_x_2 of { happy_var_2 -> + case happyOut138 happy_x_4 of { happy_var_4 -> + happyIn138 + (LetStmt happy_var_2 : happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_340 = happyReduce 6# 134# happyReduction_340 +happyReduction_340 (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 happyOut136 happy_x_1 of { happy_var_1 -> + case happyOut174 happy_x_2 of { happy_var_2 -> + case happyOut99 happy_x_4 of { happy_var_4 -> + case happyOut138 happy_x_6 of { happy_var_6 -> + happyIn138 + (Generator happy_var_2 happy_var_1 happy_var_4 : happy_var_6 + ) `HappyStk` happyRest}}}} + +happyReduce_341 = happySpecReduce_3 134# happyReduction_341 +happyReduction_341 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut99 happy_x_1 of { happy_var_1 -> + case happyOut138 happy_x_3 of { happy_var_3 -> + happyIn138 + (Qualifier happy_var_1 : happy_var_3 + )}} + +happyReduce_342 = happySpecReduce_2 134# happyReduction_342 +happyReduction_342 happy_x_2 + happy_x_1 + = case happyOut138 happy_x_2 of { happy_var_2 -> + happyIn138 + (happy_var_2 + )} + +happyReduce_343 = happySpecReduce_2 134# happyReduction_343 +happyReduction_343 happy_x_2 + happy_x_1 + = case happyOut99 happy_x_1 of { happy_var_1 -> + happyIn138 + ([Qualifier happy_var_1] + )} + +happyReduce_344 = happySpecReduce_1 134# happyReduction_344 +happyReduction_344 happy_x_1 + = case happyOut99 happy_x_1 of { happy_var_1 -> + happyIn138 + ([Qualifier happy_var_1] + )} + +happyReduce_345 = happySpecReduce_3 135# happyReduction_345 +happyReduction_345 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut139 happy_x_1 of { happy_var_1 -> + case happyOut140 happy_x_3 of { happy_var_3 -> + happyIn139 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_346 = happySpecReduce_1 135# happyReduction_346 +happyReduction_346 happy_x_1 + = case happyOut140 happy_x_1 of { happy_var_1 -> + happyIn139 + ([happy_var_1] + )} + +happyReduce_347 = happySpecReduce_3 136# happyReduction_347 +happyReduction_347 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut147 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + happyIn140 + (FieldUpdate happy_var_1 happy_var_3 + )}} + +happyReduce_348 = happySpecReduce_3 137# happyReduction_348 +happyReduction_348 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut142 happy_x_2 of { happy_var_2 -> + happyIn141 + (reverse happy_var_2 + )} + +happyReduce_349 = happySpecReduce_3 138# happyReduction_349 +happyReduction_349 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut142 happy_x_1 of { happy_var_1 -> + case happyOut143 happy_x_3 of { happy_var_3 -> + happyIn142 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_350 = happySpecReduce_1 138# happyReduction_350 +happyReduction_350 happy_x_1 + = case happyOut143 happy_x_1 of { happy_var_1 -> + happyIn142 + ([happy_var_1] + )} + +happyReduce_351 = happyReduce 4# 139# happyReduction_351 +happyReduction_351 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut174 happy_x_1 of { happy_var_1 -> + case happyOut148 happy_x_2 of { happy_var_2 -> + case happyOut99 happy_x_4 of { happy_var_4 -> + happyIn143 + (IPBind happy_var_1 happy_var_2 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_352 = happySpecReduce_2 140# happyReduction_352 +happyReduction_352 happy_x_2 + happy_x_1 + = happyIn144 + (p_unit_con + ) + +happyReduce_353 = happySpecReduce_2 140# happyReduction_353 +happyReduction_353 happy_x_2 + happy_x_1 + = happyIn144 + (List [] + ) + +happyReduce_354 = happySpecReduce_3 140# happyReduction_354 +happyReduction_354 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut112 happy_x_2 of { happy_var_2 -> + happyIn144 + (p_tuple_con happy_var_2 + )} + +happyReduce_355 = happySpecReduce_1 140# happyReduction_355 +happyReduction_355 happy_x_1 + = case happyOut150 happy_x_1 of { happy_var_1 -> + happyIn144 + (Con happy_var_1 + )} + +happyReduce_356 = happySpecReduce_1 141# happyReduction_356 +happyReduction_356 happy_x_1 + = case happyOut162 happy_x_1 of { happy_var_1 -> + happyIn145 + (happy_var_1 + )} + +happyReduce_357 = happySpecReduce_3 141# happyReduction_357 +happyReduction_357 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut170 happy_x_2 of { happy_var_2 -> + happyIn145 + (happy_var_2 + )} + +happyReduce_358 = happySpecReduce_1 142# happyReduction_358 +happyReduction_358 happy_x_1 + = case happyOut161 happy_x_1 of { happy_var_1 -> + happyIn146 + (happy_var_1 + )} + +happyReduce_359 = happySpecReduce_3 142# happyReduction_359 +happyReduction_359 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut170 happy_x_2 of { happy_var_2 -> + happyIn146 + (happy_var_2 + )} + +happyReduce_360 = happySpecReduce_1 143# happyReduction_360 +happyReduction_360 happy_x_1 + = case happyOut160 happy_x_1 of { happy_var_1 -> + happyIn147 + (happy_var_1 + )} + +happyReduce_361 = happySpecReduce_3 143# happyReduction_361 +happyReduction_361 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut168 happy_x_2 of { happy_var_2 -> + happyIn147 + (happy_var_2 + )} + +happyReduce_362 = happySpecReduce_1 144# happyReduction_362 +happyReduction_362 happy_x_1 + = case happyOut163 happy_x_1 of { happy_var_1 -> + happyIn148 + (happy_var_1 + )} + +happyReduce_363 = happySpecReduce_1 145# happyReduction_363 +happyReduction_363 happy_x_1 + = case happyOut165 happy_x_1 of { happy_var_1 -> + happyIn149 + (happy_var_1 + )} + +happyReduce_364 = happySpecReduce_3 145# happyReduction_364 +happyReduction_364 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut167 happy_x_2 of { happy_var_2 -> + happyIn149 + (happy_var_2 + )} + +happyReduce_365 = happySpecReduce_1 146# happyReduction_365 +happyReduction_365 happy_x_1 + = case happyOut164 happy_x_1 of { happy_var_1 -> + happyIn150 + (happy_var_1 + )} + +happyReduce_366 = happySpecReduce_3 146# happyReduction_366 +happyReduction_366 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut159 happy_x_2 of { happy_var_2 -> + happyIn150 + (happy_var_2 + )} + +happyReduce_367 = happySpecReduce_1 147# happyReduction_367 +happyReduction_367 happy_x_1 + = case happyOut170 happy_x_1 of { happy_var_1 -> + happyIn151 + (happy_var_1 + )} + +happyReduce_368 = happySpecReduce_3 147# happyReduction_368 +happyReduction_368 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut162 happy_x_2 of { happy_var_2 -> + happyIn151 + (happy_var_2 + )} + +happyReduce_369 = happySpecReduce_1 148# happyReduction_369 +happyReduction_369 happy_x_1 + = case happyOut168 happy_x_1 of { happy_var_1 -> + happyIn152 + (happy_var_1 + )} + +happyReduce_370 = happySpecReduce_3 148# happyReduction_370 +happyReduction_370 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut160 happy_x_2 of { happy_var_2 -> + happyIn152 + (happy_var_2 + )} + +happyReduce_371 = happySpecReduce_1 149# happyReduction_371 +happyReduction_371 happy_x_1 + = case happyOut169 happy_x_1 of { happy_var_1 -> + happyIn153 + (happy_var_1 + )} + +happyReduce_372 = happySpecReduce_3 149# happyReduction_372 +happyReduction_372 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut160 happy_x_2 of { happy_var_2 -> + happyIn153 + (happy_var_2 + )} + +happyReduce_373 = happySpecReduce_1 150# happyReduction_373 +happyReduction_373 happy_x_1 + = case happyOut167 happy_x_1 of { happy_var_1 -> + happyIn154 + (happy_var_1 + )} + +happyReduce_374 = happySpecReduce_3 150# happyReduction_374 +happyReduction_374 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut165 happy_x_2 of { happy_var_2 -> + happyIn154 + (happy_var_2 + )} + +happyReduce_375 = happySpecReduce_1 151# happyReduction_375 +happyReduction_375 happy_x_1 + = case happyOut159 happy_x_1 of { happy_var_1 -> + happyIn155 + (happy_var_1 + )} + +happyReduce_376 = happySpecReduce_3 151# happyReduction_376 +happyReduction_376 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut164 happy_x_2 of { happy_var_2 -> + happyIn155 + (happy_var_2 + )} + +happyReduce_377 = happySpecReduce_1 152# happyReduction_377 +happyReduction_377 happy_x_1 + = case happyOut151 happy_x_1 of { happy_var_1 -> + happyIn156 + (VarOp happy_var_1 + )} + +happyReduce_378 = happySpecReduce_1 152# happyReduction_378 +happyReduction_378 happy_x_1 + = case happyOut154 happy_x_1 of { happy_var_1 -> + happyIn156 + (ConOp happy_var_1 + )} + +happyReduce_379 = happySpecReduce_1 153# happyReduction_379 +happyReduction_379 happy_x_1 + = case happyOut152 happy_x_1 of { happy_var_1 -> + happyIn157 + (QVarOp happy_var_1 + )} + +happyReduce_380 = happySpecReduce_1 153# happyReduction_380 +happyReduction_380 happy_x_1 + = case happyOut155 happy_x_1 of { happy_var_1 -> + happyIn157 + (QConOp happy_var_1 + )} + +happyReduce_381 = happySpecReduce_1 154# happyReduction_381 +happyReduction_381 happy_x_1 + = case happyOut153 happy_x_1 of { happy_var_1 -> + happyIn158 + (QVarOp happy_var_1 + )} + +happyReduce_382 = happySpecReduce_1 154# happyReduction_382 +happyReduction_382 happy_x_1 + = case happyOut155 happy_x_1 of { happy_var_1 -> + happyIn158 + (QConOp happy_var_1 + )} + +happyReduce_383 = happySpecReduce_1 155# happyReduction_383 +happyReduction_383 happy_x_1 + = happyIn159 + (list_cons_name + ) + +happyReduce_384 = happySpecReduce_1 155# happyReduction_384 +happyReduction_384 happy_x_1 + = case happyOut166 happy_x_1 of { happy_var_1 -> + happyIn159 + (happy_var_1 + )} + +happyReduce_385 = happySpecReduce_1 156# happyReduction_385 +happyReduction_385 happy_x_1 + = case happyOut162 happy_x_1 of { happy_var_1 -> + happyIn160 + (UnQual happy_var_1 + )} + +happyReduce_386 = happySpecReduce_1 156# happyReduction_386 +happyReduction_386 happy_x_1 + = case happyOutTok happy_x_1 of { (QVarId happy_var_1) -> + happyIn160 + (Qual (ModuleName (fst happy_var_1)) (Ident (snd happy_var_1)) + )} + +happyReduce_387 = happySpecReduce_1 157# happyReduction_387 +happyReduction_387 happy_x_1 + = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> + happyIn161 + (Ident happy_var_1 + )} + +happyReduce_388 = happySpecReduce_1 157# happyReduction_388 +happyReduction_388 happy_x_1 + = happyIn161 + (as_name + ) + +happyReduce_389 = happySpecReduce_1 157# happyReduction_389 +happyReduction_389 happy_x_1 + = happyIn161 + (qualified_name + ) + +happyReduce_390 = happySpecReduce_1 157# happyReduction_390 +happyReduction_390 happy_x_1 + = happyIn161 + (hiding_name + ) + +happyReduce_391 = happySpecReduce_1 157# happyReduction_391 +happyReduction_391 happy_x_1 + = happyIn161 + (export_name + ) + +happyReduce_392 = happySpecReduce_1 157# happyReduction_392 +happyReduction_392 happy_x_1 + = happyIn161 + (stdcall_name + ) + +happyReduce_393 = happySpecReduce_1 157# happyReduction_393 +happyReduction_393 happy_x_1 + = happyIn161 + (ccall_name + ) + +happyReduce_394 = happySpecReduce_1 158# happyReduction_394 +happyReduction_394 happy_x_1 + = case happyOut161 happy_x_1 of { happy_var_1 -> + happyIn162 + (happy_var_1 + )} + +happyReduce_395 = happySpecReduce_1 158# happyReduction_395 +happyReduction_395 happy_x_1 + = happyIn162 + (safe_name + ) + +happyReduce_396 = happySpecReduce_1 158# happyReduction_396 +happyReduction_396 happy_x_1 + = happyIn162 + (unsafe_name + ) + +happyReduce_397 = happySpecReduce_1 158# happyReduction_397 +happyReduction_397 happy_x_1 + = happyIn162 + (threadsafe_name + ) + +happyReduce_398 = happySpecReduce_1 159# happyReduction_398 +happyReduction_398 happy_x_1 + = case happyOutTok happy_x_1 of { (IDupVarId happy_var_1) -> + happyIn163 + (IPDup happy_var_1 + )} + +happyReduce_399 = happySpecReduce_1 159# happyReduction_399 +happyReduction_399 happy_x_1 + = case happyOutTok happy_x_1 of { (ILinVarId happy_var_1) -> + happyIn163 + (IPLin happy_var_1 + )} + +happyReduce_400 = happySpecReduce_1 160# happyReduction_400 +happyReduction_400 happy_x_1 + = case happyOut165 happy_x_1 of { happy_var_1 -> + happyIn164 + (UnQual happy_var_1 + )} + +happyReduce_401 = happySpecReduce_1 160# happyReduction_401 +happyReduction_401 happy_x_1 + = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> + happyIn164 + (Qual (ModuleName (fst happy_var_1)) (Ident (snd happy_var_1)) + )} + +happyReduce_402 = happySpecReduce_1 161# happyReduction_402 +happyReduction_402 happy_x_1 + = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> + happyIn165 + (Ident happy_var_1 + )} + +happyReduce_403 = happySpecReduce_1 162# happyReduction_403 +happyReduction_403 happy_x_1 + = case happyOut167 happy_x_1 of { happy_var_1 -> + happyIn166 + (UnQual happy_var_1 + )} + +happyReduce_404 = happySpecReduce_1 162# happyReduction_404 +happyReduction_404 happy_x_1 + = case happyOutTok happy_x_1 of { (QConSym happy_var_1) -> + happyIn166 + (Qual (ModuleName (fst happy_var_1)) (Symbol (snd happy_var_1)) + )} + +happyReduce_405 = happySpecReduce_1 163# happyReduction_405 +happyReduction_405 happy_x_1 + = case happyOutTok happy_x_1 of { (ConSym happy_var_1) -> + happyIn167 + (Symbol happy_var_1 + )} + +happyReduce_406 = happySpecReduce_1 164# happyReduction_406 +happyReduction_406 happy_x_1 + = case happyOut170 happy_x_1 of { happy_var_1 -> + happyIn168 + (UnQual happy_var_1 + )} + +happyReduce_407 = happySpecReduce_1 164# happyReduction_407 +happyReduction_407 happy_x_1 + = case happyOut172 happy_x_1 of { happy_var_1 -> + happyIn168 + (happy_var_1 + )} + +happyReduce_408 = happySpecReduce_1 165# happyReduction_408 +happyReduction_408 happy_x_1 + = case happyOut171 happy_x_1 of { happy_var_1 -> + happyIn169 + (UnQual happy_var_1 + )} + +happyReduce_409 = happySpecReduce_1 165# happyReduction_409 +happyReduction_409 happy_x_1 + = case happyOut172 happy_x_1 of { happy_var_1 -> + happyIn169 + (happy_var_1 + )} + +happyReduce_410 = happySpecReduce_1 166# happyReduction_410 +happyReduction_410 happy_x_1 + = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> + happyIn170 + (Symbol happy_var_1 + )} + +happyReduce_411 = happySpecReduce_1 166# happyReduction_411 +happyReduction_411 happy_x_1 + = happyIn170 + (minus_name + ) + +happyReduce_412 = happySpecReduce_1 166# happyReduction_412 +happyReduction_412 happy_x_1 + = happyIn170 + (pling_name + ) + +happyReduce_413 = happySpecReduce_1 166# happyReduction_413 +happyReduction_413 happy_x_1 + = happyIn170 + (dot_name + ) + +happyReduce_414 = happySpecReduce_1 166# happyReduction_414 +happyReduction_414 happy_x_1 + = happyIn170 + (star_name + ) + +happyReduce_415 = happySpecReduce_1 167# happyReduction_415 +happyReduction_415 happy_x_1 + = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> + happyIn171 + (Symbol happy_var_1 + )} + +happyReduce_416 = happySpecReduce_1 167# happyReduction_416 +happyReduction_416 happy_x_1 + = happyIn171 + (pling_name + ) + +happyReduce_417 = happySpecReduce_1 167# happyReduction_417 +happyReduction_417 happy_x_1 + = happyIn171 + (dot_name + ) + +happyReduce_418 = happySpecReduce_1 167# happyReduction_418 +happyReduction_418 happy_x_1 + = happyIn171 + (star_name + ) + +happyReduce_419 = happySpecReduce_1 168# happyReduction_419 +happyReduction_419 happy_x_1 + = case happyOutTok happy_x_1 of { (QVarSym happy_var_1) -> + happyIn172 + (Qual (ModuleName (fst happy_var_1)) (Symbol (snd happy_var_1)) + )} + +happyReduce_420 = happySpecReduce_1 169# happyReduction_420 +happyReduction_420 happy_x_1 + = case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> + happyIn173 + (Int happy_var_1 + )} + +happyReduce_421 = happySpecReduce_1 169# happyReduction_421 +happyReduction_421 happy_x_1 + = case happyOutTok happy_x_1 of { (Character happy_var_1) -> + happyIn173 + (Char happy_var_1 + )} + +happyReduce_422 = happySpecReduce_1 169# happyReduction_422 +happyReduction_422 happy_x_1 + = case happyOutTok happy_x_1 of { (FloatTok happy_var_1) -> + happyIn173 + (Frac happy_var_1 + )} + +happyReduce_423 = happySpecReduce_1 169# happyReduction_423 +happyReduction_423 happy_x_1 + = case happyOutTok happy_x_1 of { (StringTok happy_var_1) -> + happyIn173 + (String happy_var_1 + )} + +happyReduce_424 = happyMonadReduce 0# 170# happyReduction_424 +happyReduction_424 (happyRest) tk + = happyThen (( getSrcLoc) + ) (\r -> happyReturn (happyIn174 r)) + +happyReduce_425 = happyMonadReduce 0# 171# happyReduction_425 +happyReduction_425 (happyRest) tk + = happyThen (( pushCurrentContext) + ) (\r -> happyReturn (happyIn175 r)) + +happyReduce_426 = happySpecReduce_1 172# happyReduction_426 +happyReduction_426 happy_x_1 + = happyIn176 + (() + ) + +happyReduce_427 = happyMonadReduce 1# 172# happyReduction_427 +happyReduction_427 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (( popContext) + ) (\r -> happyReturn (happyIn176 r)) + +happyReduce_428 = happySpecReduce_1 173# happyReduction_428 +happyReduction_428 happy_x_1 + = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> + happyIn177 + (ModuleName happy_var_1 + )} + +happyReduce_429 = happySpecReduce_1 173# happyReduction_429 +happyReduction_429 happy_x_1 + = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> + happyIn177 + (ModuleName (fst happy_var_1 ++ '.':snd happy_var_1) + )} + +happyReduce_430 = happySpecReduce_1 174# happyReduction_430 +happyReduction_430 happy_x_1 + = case happyOut165 happy_x_1 of { happy_var_1 -> + happyIn178 + (happy_var_1 + )} + +happyReduce_431 = happySpecReduce_1 175# happyReduction_431 +happyReduction_431 happy_x_1 + = case happyOut164 happy_x_1 of { happy_var_1 -> + happyIn179 + (happy_var_1 + )} + +happyReduce_432 = happySpecReduce_1 176# happyReduction_432 +happyReduction_432 happy_x_1 + = case happyOut164 happy_x_1 of { happy_var_1 -> + happyIn180 + (happy_var_1 + )} + +happyReduce_433 = happySpecReduce_1 177# happyReduction_433 +happyReduction_433 happy_x_1 + = case happyOut162 happy_x_1 of { happy_var_1 -> + happyIn181 + (happy_var_1 + )} + +happyReduce_434 = happySpecReduce_3 178# happyReduction_434 +happyReduction_434 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut181 happy_x_2 of { happy_var_2 -> + happyIn182 + (UnQual happy_var_2 + )} + +happyReduce_435 = happySpecReduce_1 178# happyReduction_435 +happyReduction_435 happy_x_1 + = case happyOut183 happy_x_1 of { happy_var_1 -> + happyIn182 + (UnQual happy_var_1 + )} + +happyReduce_436 = happySpecReduce_1 179# happyReduction_436 +happyReduction_436 happy_x_1 + = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> + happyIn183 + (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 99# tk action sts stk; + VarId happy_dollar_dollar -> cont 1#; + QVarId happy_dollar_dollar -> cont 2#; + IDupVarId happy_dollar_dollar -> cont 3#; + ILinVarId happy_dollar_dollar -> cont 4#; + ConId happy_dollar_dollar -> cont 5#; + QConId happy_dollar_dollar -> cont 6#; + DVarId happy_dollar_dollar -> cont 7#; + VarSym happy_dollar_dollar -> cont 8#; + ConSym happy_dollar_dollar -> cont 9#; + QVarSym happy_dollar_dollar -> cont 10#; + QConSym happy_dollar_dollar -> cont 11#; + IntTok happy_dollar_dollar -> cont 12#; + FloatTok happy_dollar_dollar -> cont 13#; + Character happy_dollar_dollar -> cont 14#; + StringTok happy_dollar_dollar -> cont 15#; + LeftParen -> cont 16#; + RightParen -> cont 17#; + LeftHashParen -> cont 18#; + RightHashParen -> cont 19#; + SemiColon -> cont 20#; + LeftCurly -> cont 21#; + RightCurly -> cont 22#; + VRightCurly -> cont 23#; + LeftSquare -> cont 24#; + RightSquare -> cont 25#; + Comma -> cont 26#; + Underscore -> cont 27#; + BackQuote -> cont 28#; + Dot -> cont 29#; + DotDot -> cont 30#; + Colon -> cont 31#; + DoubleColon -> cont 32#; + Equals -> cont 33#; + Backslash -> cont 34#; + Bar -> cont 35#; + LeftArrow -> cont 36#; + RightArrow -> cont 37#; + At -> cont 38#; + Tilde -> cont 39#; + DoubleArrow -> cont 40#; + Minus -> cont 41#; + Exclamation -> cont 42#; + Star -> cont 43#; + RPGuardOpen -> cont 44#; + RPGuardClose -> cont 45#; + RPCAt -> cont 46#; + THIdEscape happy_dollar_dollar -> cont 47#; + THParenEscape -> cont 48#; + THExpQuote -> cont 49#; + THPatQuote -> cont 50#; + THTypQuote -> cont 51#; + THDecQuote -> cont 52#; + THCloseQuote -> cont 53#; + THVarQuote -> cont 54#; + THTyQuote -> cont 55#; + XPCDATA happy_dollar_dollar -> cont 56#; + XStdTagOpen -> cont 57#; + XCloseTagOpen -> cont 58#; + XCodeTagOpen -> cont 59#; + XStdTagClose -> cont 60#; + XEmptyTagClose -> cont 61#; + XCodeTagClose -> cont 62#; + XRPatOpen -> cont 63#; + XRPatClose -> cont 64#; + KW_Foreign -> cont 65#; + KW_Export -> cont 66#; + KW_Safe -> cont 67#; + KW_Unsafe -> cont 68#; + KW_Threadsafe -> cont 69#; + KW_StdCall -> cont 70#; + KW_CCall -> cont 71#; + KW_As -> cont 72#; + KW_Case -> cont 73#; + KW_Class -> cont 74#; + KW_Data -> cont 75#; + KW_Default -> cont 76#; + KW_Deriving -> cont 77#; + KW_Do -> cont 78#; + KW_Else -> cont 79#; + KW_Family -> cont 80#; + KW_Forall -> cont 81#; + KW_Hiding -> cont 82#; + KW_If -> cont 83#; + KW_Import -> cont 84#; + KW_In -> cont 85#; + KW_Infix -> cont 86#; + KW_InfixL -> cont 87#; + KW_InfixR -> cont 88#; + KW_Instance -> cont 89#; + KW_Let -> cont 90#; + KW_MDo -> cont 91#; + KW_Module -> cont 92#; + KW_NewType -> cont 93#; + KW_Of -> cont 94#; + KW_Then -> cont 95#; + KW_Type -> cont 96#; + KW_Where -> cont 97#; + KW_Qualified -> cont 98#; + _ -> 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" #-}
haskell-src-exts.cabal view
@@ -1,5 +1,5 @@ Name: haskell-src-exts-Version: 0.3.12+Version: 0.4.1 License: BSD3 License-File: LICENSE Author: Niklas Broberg@@ -28,13 +28,10 @@ . For details on usage, please see the website. Homepage: http://code.haskell.org/HSP/haskell-src-exts-Stability: Experimental+Stability: Stable Tested-with: GHC==6.10.1 Build-Type: Simple Cabal-Version: >= 1.2--Flag splitBase- Description: Choose the new smaller, split-up base package. Library Build-Tools: happy >= 1.17