diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +Copyright (c)2012, Scott West + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Scott West nor the names of other + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/Language/Eiffel/Parser.hs b/Language/Eiffel/Parser.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Parser.hs @@ -0,0 +1,61 @@ +{-# LANGUAGE BangPatterns #-} +module Language.Eiffel.Parser where + +import qualified Data.Text as Text +import qualified Data.Text.IO as Text +import Data.Text (Text) + +import Language.Eiffel.Syntax +import Language.Eiffel.Parser.Class +import qualified Language.Eiffel.Parser.Lex as L +import Language.Eiffel.Parser.Statement + +import Text.Parsec +import Text.Parsec.Error +import Text.Parsec.Pos + +newError name err = newErrorMessage (Message err) (newPos name 0 0) + +lexThenParse :: L.Parser a -> String -> Text -> Either ParseError a +lexThenParse p name bstr = + let lexed = L.tokenizer name bstr -- parse L.tokenizer name bstr + in case lexed of + Left err -> Left (newError name err) + Right tks -> parse p name tks + +lexThenParseFromFile :: L.Parser a -> String -> IO (Either ParseError a) +lexThenParseFromFile p name = do + !lexed <- L.tokenizeFile name + case lexed of + Left err -> return $ Left $ newError name err + Right tks -> return $ parse p name tks + +countTokens :: String -> IO (Int) +countTokens name = do + lexed <- L.tokenizeFile name -- parseFromFile L.tokenizer name + case lexed of + Left _err -> return 0 + Right tks -> return $ length tks + +parseStmt :: Text -> Either ParseError Stmt +parseStmt = lexThenParse stmt "" + +parseClass :: Text -> Either ParseError Clas +parseClass = lexThenParse clas "" + +parseInterface :: Text -> Either ParseError ClasInterface +parseInterface = lexThenParse clasInterfaceP "" + +parseClass' :: Text -> Clas +parseClass' = either (error . show) id . parseClass + +parseFromName :: ClassName -> IO Clas +parseFromName cn = + either (error . show) return . parseClass =<< + Text.readFile (classNameFile cn) + +classNameFile :: ClassName -> String +classNameFile cn = Text.unpack (Text.toLower cn) ++ ".e" + +parseClassFile :: String -> IO (Either ParseError Clas) +parseClassFile = lexThenParseFromFile clas diff --git a/Language/Eiffel/Parser/Class.hs b/Language/Eiffel/Parser/Class.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Parser/Class.hs @@ -0,0 +1,224 @@ +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE OverloadedStrings #-} +module Language.Eiffel.Parser.Class where + +import Control.Applicative ((<$>), (<*>), (<*), (*>)) + +import qualified Data.HashMap.Strict as Map +import qualified Data.Set as Set +import Data.Set (Set) +import qualified Data.Text as Text +import Data.Text (Text) + +import Language.Eiffel.Syntax +import Language.Eiffel.Util + +import Language.Eiffel.Parser.Lex +import Language.Eiffel.Parser.Clause +import Language.Eiffel.Parser.Expr +import Language.Eiffel.Parser.Feature +import Language.Eiffel.Parser.Note +import Language.Eiffel.Parser.Typ + +import Text.Parsec + +genericsP :: Parser [Generic] +genericsP = squares (sepBy genericP comma) + +genericP :: Parser Generic +genericP = do + name <- identifier + typs <- option [] (do opNamed "->" + braces (typ `sepBy1` comma) <|> fmap (replicate 1) typ) + creations <- optionMaybe + (keyword TokCreate *> (identifier `sepBy1` comma) <* keyword TokEnd) + return (Generic name typs creations) + +invariants :: Parser [Clause Expr] +invariants = keyword TokInvariant >> many clause + +inherits :: Parser [Inheritance] +inherits = many inheritP + +inheritP = do + keyword TokInherit + nonConf <- (braces identifier >> return True) <|> return False + inClauses <- many inheritClauseP + return (Inheritance nonConf inClauses) + +inheritClauseP :: Parser InheritClause +inheritClauseP = do + t <- classTyp + (do + lookAhead (keyword TokRename <|> keyword TokExport <|> keyword TokUndefine <|> keyword TokRedefine <|> keyword TokSelect) + renames <- option [] renameP + exports <- option [] exportP + undefs <- option [] undefineP + redefs <- option [] redefineP + selects <- option [] selectP + keyword TokEnd + return (InheritClause t renames exports undefs redefs selects)) <|> (return $ InheritClause t [] [] [] [] []) + +renameP :: Parser [RenameClause] +renameP = do + keyword TokRename + renameName `sepBy` comma + +renameName :: Parser RenameClause +renameName = do + Rename <$> identifier + <*> (keyword TokAs >> identifier) + <*> optionMaybe alias + +exportP :: Parser [ExportClause] +exportP = do + keyword TokExport + many (do + to <- braces (identifier `sepBy` comma) + (do keyword TokAll; return $ Export to ExportAll) <|> (do what <- identifier `sepBy` comma; return $ Export to (ExportFeatureNames what))) + +undefineP = do + keyword TokUndefine + identifier `sepBy` comma + +redefineP = do + keyword TokRedefine + identifier `sepBy` comma + +selectP = do + keyword TokSelect + identifier `sepBy` comma + +create :: Parser CreateClause +create = do + keyword TokCreate + exports <- option [] (braces (identifier `sepBy` comma)) + names <- identifier `sepBy` comma + return (CreateClause exports names) + +convertsP :: Parser [ConvertClause] +convertsP = do + keyword TokConvert + convert `sepBy` comma + +convert :: Parser ConvertClause +convert = do + fname <- identifier + (do + colon + ts <- braces (typ `sepBy1` comma) + return (ConvertTo fname ts)) <|> (do + ts <- parens (braces (typ `sepBy1` comma)) + return (ConvertFrom fname ts)) + +absClas :: Parser body -> Parser (AbsClas body Expr) +absClas routineP = do + notes <- option [] note + frz <- option False (keyword TokFrozen >> return True) + expand <- option False (keyword TokExpanded >> return True) + def <- option False (keyword TokDeferred >> return True) + keyword TokClass + name <- identifier + gen <- option [] genericsP + obs <- option False (keyword TokObsolete >> + option True (anyStringTok >> return True)) + is <- option [] inherits + cs <- many create + cnvs <- option [] convertsP + fcs <- absFeatureSects routineP + invs <- option [] invariants + endNotes <- option [] note + keyword TokEnd + return ( AbsClas + { frozenClass = frz + , expandedClass = expand + , deferredClass = def + , classNote = notes ++ endNotes + , className = name + , currProc = Dot + , generics = gen + , obsoleteClass = obs + , inherit = is + , creates = cs + , converts = cnvs + , featureMap = fcs + , invnts = invs + , procGeneric = [] + , procExpr = [] + } + ) + +absFeatureSects :: Parser body + -> Parser (FeatureMap body Expr) +absFeatureSects bodyP = fmUnions <$> many (absFeatureSect bodyP) + +absFeatureSect :: Parser body + -> Parser (FeatureMap body Expr) +absFeatureSect routineP = do + keyword TokFeature + exports <- Set.fromList <$> option [] (braces (identifier `sepBy` comma)) + fmUnions <$> many (featureMember exports routineP) + +constWithHead fHead t = + let mkConst (NameAlias frz name _als) = Constant frz (Decl name t) + constStarts = map mkConst (fHeadNameAliases fHead) + in do + e <- opInfo (RelOp Eq NoType) >> expr + optional semicolon + return (map ($ e) constStarts) + +attrWithHead fHead assign notes reqs t = do + ens <- if not (null notes) || not (null (contractClauses reqs)) + then do + keyword TokAttribute + ens <- option (Contract True []) ensures + keyword TokEnd + return ens + else optional (keyword TokAttribute >> keyword TokEnd) >> + return (Contract False []) + let mkAttr (NameAlias frz name _als) = + Attribute frz (Decl name t) assign notes reqs ens + return (map mkAttr (fHeadNameAliases fHead)) + +featureMember :: Set Text -> Parser body -> Parser (FeatureMap body Expr) +featureMember exports fp = do + fHead <- featureHead + + let + mkMap :: Feature f Expr + => [f] + -> Map Text (ExportedFeature f) + mkMap = + Map.fromList . + map (\f -> (Text.toLower (featureName f), ExportedFeature exports f)) + + mkRoutMap x = FeatureMap x Map.empty Map.empty + mkAttrMap x = FeatureMap Map.empty x Map.empty + mkConstMap x = FeatureMap Map.empty Map.empty x + + constant = case fHeadRes fHead of + NoType -> fail "featureOrDecl: constant expects type" + t -> mkConstMap <$> mkMap <$> constWithHead fHead t + + attrOrRoutine = do + assign <- optionMaybe assigner + notes <- option [] note + reqs <- option (Contract True []) requires + + let + rout = routine fHead assign notes reqs fp + someRout = mkRoutMap <$> mkMap <$> rout + case fHeadRes fHead of + NoType -> someRout + t -> someRout <|> + (mkAttrMap <$> mkMap <$> attrWithHead fHead assign notes reqs t) + constant <|> attrOrRoutine <* optional semicolon + +clas :: Parser Clas +clas = absClas routineImplP + +clasInterfaceP :: Parser ClasInterface +clasInterfaceP = absClas (keyword TokDo >> return EmptyBody) + + + diff --git a/Language/Eiffel/Parser/Clause.hs b/Language/Eiffel/Parser/Clause.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Parser/Clause.hs @@ -0,0 +1,23 @@ +module Language.Eiffel.Parser.Clause where + +import Control.Applicative ((<$>), (<*)) + +import Language.Eiffel.Syntax + +import Language.Eiffel.Parser.Expr +import Language.Eiffel.Parser.Lex +import Language.Eiffel.Position + +import Text.Parsec + +clause :: Parser (Clause Expr) +clause = do + let tagNoExpr = do + i <- identifier <* colon + p <- getPosition + e <- option (attachPos p (LitBool True)) expr + return (Clause (Just i) e) + withExpr = do + tag <- try (Just <$> identifier <* colon) <|> return Nothing + Clause tag <$> expr + in try tagNoExpr <|> withExpr diff --git a/Language/Eiffel/Parser/Expr.hs b/Language/Eiffel/Parser/Expr.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Parser/Expr.hs @@ -0,0 +1,233 @@ +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE BangPatterns #-} +module Language.Eiffel.Parser.Expr (expr, call, var, manifest) where + +import Control.Applicative ((<$>), (*>)) + +import Language.Eiffel.Syntax +import Language.Eiffel.Parser.Lex +import {-# SOURCE #-} Language.Eiffel.Parser.Statement +import Language.Eiffel.Position +import Language.Eiffel.Parser.Typ + +import Text.Parsec + +expr :: Parser Expr +expr = expr' 0 + +expr' :: Int -> Parser Expr +expr' minPrec = + let + loop :: Expr -> Parser Expr + loop result = + let go = do + (op, prec, opAssoc) <- binOpToken minPrec + let nextMinPrec = case opAssoc of + AssocLeft -> prec + 1 + _ -> prec + rhs <- expr' nextMinPrec + result' <- attachTokenPos (return $ BinOpExpr op result rhs) + loop result' + in go <|> return result + in factor >>= loop + +factor :: Parser Expr +factor = attachTokenPos factorUnPos + +factorUnPos :: Parser UnPosExpr +factorUnPos = choice [ tuple + , onceString + , address + , agent + , across + , question + , attached + , createExpr + , varOrCall + , precursorCall + , void + , manifest + , unaryExpr + ] + +unaryExpr = + let + notP = do + keyword TokNot + UnOpExpr Not <$> factor + oldP = do + keyword TokOld + UnOpExpr Old <$> factor + negP = do + opInfo Sub + UnOpExpr Neg <$> factor + unAddP = do + opInfo Add + contents <$> factor + in notP <|> oldP <|> negP <|> unAddP + +onceString = do + keyword TokOnce + s <- anyStringTok + return (OnceStr s) + +address = do + opNamed "$" + p <- getPosition + e <- VarOrCall <$> identifier <|> resultVar <|> currentVar + return (Address $ attachPos p e) + +manifest = choice [ doubleLit + , intLit + , boolLit + , stringLit + , charLit + , arrayLit + , typeLitOrManifest + ] + +arrayLit = do + arrayStart + elems <- expr `sepBy` comma + arrayEnd + return (LitArray elems) + +across = do + keyword TokAcross + e <- expr + keyword TokAs + i <- identifier + quant <- (keyword TokAll *> return All) <|> (keyword TokSome *> return Some) + body <- expr + keyword TokEnd + return (AcrossExpr e i quant body) + +tuple = Tuple <$> squares (expr `sepBy` comma) + +question = do + symbol '?' + return (VarOrCall "?") + +agent = do + keyword TokAgent + p <- getPosition + inlineAgent <|> (Agent <$> attachPos p <$> varOrCall) + +inlineAgent = do + argDecls <- try argumentList + resultType <- optionMaybe (colon >> typ) + keyword TokDo + stmts <- many stmt + keyword TokEnd + args <- option [] argsP + return (InlineAgent argDecls resultType stmts args) + +varOrCall = + let identStart = do + i <- identifier + (UnqualCall i <$> argsP) <|> return (VarOrCall i) + specialStart = resultVar <|> currentVar + + bracketCall = do + p <- getPosition + t <- manifest <|> tuple + call' (attachPos p t) + in do + p <- getPosition + t <- specialStart <|> identStart <|> try staticCall <|> + (contents <$> (parens expr)) <|> bracketCall + call' (attachPos p t) + +call' :: Expr -> Parser UnPosExpr +call' targ = + let periodStart = do + period + i <- identifier + p <- getPosition + args <- option [] argsP + call' (attachPos p $ QualCall targ i args) + squareStart = do + p <- getPosition + es <- squares (expr `sepBy` comma) + call' (attachPos p $ Lookup targ es) + in periodStart <|> squareStart <|> return (contents targ) +precursorCall = do + keyword TokPrecursor + cname <- optionMaybe (braces identifier) + args <- option [] argsP + return $ PrecursorCall cname args + +staticCall = do + t <- braces typ + period + i <- identifier + args <- option [] argsP + return $ StaticCall t i args + +stringLit = LitString <$> anyStringTok +charLit = LitChar <$> charTok + +typeLitOrManifest = do + t <- braces typ + p <- getPosition + ManifestCast t <$> attachPos p <$> manifest <|> return (LitType t) + +attached :: Parser UnPosExpr +attached = do + keyword TokAttached + cname <- optionMaybe (braces typ) + trg <- expr + newName <- optionMaybe (keyword TokAs >> identifier) + return $ Attached cname trg newName + +createExpr :: Parser UnPosExpr +createExpr = do + keyword TokCreate + t <- braces typ + (i, args) <- (do period + i <- identifier + args <- option [] argsP + return (i, args)) <|> return (defaultCreate, []) + return $ CreateExpr t i args + +void :: Parser UnPosExpr +void = keyword TokVoid >> return LitVoid + +argsP = parens (expr `sepBy` comma) + +isCall e | isCallUnPos (contents e) = return (contents e) + | otherwise = fail "not a call" + where + isCallUnPos (QualCall _ _ _) = True + isCallUnPos (UnqualCall _ _) = True + isCallUnPos (PrecursorCall _ _) = True + isCallUnPos (VarOrCall _) = True + isCallUnPos (StaticCall _ _ _) = True + isCallUnPos _ = False + +call :: Parser UnPosExpr +call = expr >>= isCall + +varAttrCall = do + i <- identifier + notFollowedBy argsP + return (VarOrCall i) + +var :: Parser UnPosExpr +var = currentVar <|> resultVar <|> varAttrCall + +resultVar :: Parser UnPosExpr +resultVar = keyword TokResult >> return ResultVar + +currentVar :: Parser UnPosExpr +currentVar = keyword TokCurrent >> return CurrentVar + +intLit :: Parser UnPosExpr +intLit = LitInt <$> integerTok + +doubleLit :: Parser UnPosExpr +doubleLit = LitDouble <$> floatTok + +boolLit :: Parser UnPosExpr +boolLit = LitBool <$> boolTok diff --git a/Language/Eiffel/Parser/Feature.hs b/Language/Eiffel/Parser/Feature.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Parser/Feature.hs @@ -0,0 +1,150 @@ +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE OverloadedStrings #-} + +module Language.Eiffel.Parser.Feature where + +import Control.Applicative ((<$>), (<*>)) + +import qualified Data.Text as Text +import Data.Text (Text) + +import Language.Eiffel.Syntax +import Language.Eiffel.Parser.Clause +import Language.Eiffel.Parser.Lex +import Language.Eiffel.Parser.Statement +import Language.Eiffel.Parser.Typ + +import Text.Parsec + +type FeatParser body exp = + Parser body -> Parser [AbsRoutine body exp] + +data FeatureHead = + FeatureHead + { fHeadNameAliases :: [NameAlias] + , fHeadArgs :: [Decl] + , fHeadRes :: Typ + } deriving Show + +data NameAlias = + NameAlias + { featureFrozen :: Bool + , featureHeadName :: Text + , featureAlias :: Maybe Text + } deriving Show + + +nameAlias = do + frz <- (keyword TokFrozen >> return True) <|> return False + name <- identifier "Feature declaration identifier" + als <- optionMaybe alias + return $ NameAlias frz name als + +featureHead = do + nameAls <- nameAlias `sepBy1` comma + args <- argumentList "Argument list" + res <- option NoType (colon >> typ) + optional (keyword TokIs) + optional obsolete + + return (FeatureHead nameAls args res) + +routine :: FeatureHead -> Maybe Text -> [Note] -> Contract Expr + -> FeatParser body Expr +routine fHead assgn notes reqs implP = do + let FeatureHead nameAls args res = fHead + + impl <- implP + ens <- option (Contract True []) ensures + rescue <- optionMaybe rescueP + keyword TokEnd + + return $ map ( \ (NameAlias frz name als) -> + AbsRoutine + { routineFroz = frz + , routineName = name + , routineAlias = als + , routineArgs = args + , routineResult = res + , routineAssigner = assgn + , routineNote = notes + , routineReq = reqs + , routineImpl = impl + , routineEns = ens + , routineRescue = rescue + , routineProcs = [] + , routineReqLk = [] + , routineEnsLk = [] + }) nameAls + +rescueP = do + keyword TokRescue + many stmt + +assigner :: Parser Text +assigner = do + keyword TokAssign + identifier + +allowedAliases :: [Text] +allowedAliases = ["[]", "|..|", "and", "and then", "or", "or else", "implies", + "xor", "not"] + +alias = + let regStr = do + str <- stringTok + if Text.all (\c -> Text.any (c ==) opSymbol) str || + str `elem` allowedAliases + then return str + else fail $ "unallowed alias symbol: " ++ Text.unpack str + squareStr = do + str <- stringTok -- FIXME: we don't lex block strings yet!, + -- used to be: blockTextTok + if str == "" then return "[]" else fail $ "unallowed alias symbol: [" ++ Text.unpack str ++ "]" + in do + keyword TokAlias + regStr <|> squareStr + +obsolete :: Parser Text +obsolete = keyword TokObsolete >> stringTok + +whichOf :: Parser a -> Parser a -> Parser Bool +whichOf p1 p2 = (p1 >> return True) <|> (p2 >> return False) + +requires :: Parser (Contract Expr) +requires = do + inherited <- whichOf (keyword TokRequireElse) (keyword TokRequire) + c <- many clause + return $ Contract inherited c + +ensures :: Parser (Contract Expr) +ensures = do + inherited <- whichOf (keyword TokEnsureThen) (keyword TokEnsure) + c <- many clause + return $ Contract inherited c + +external :: Parser (RoutineBody exp) +external = RoutineExternal <$> (keyword TokExternal >> anyStringTok) + <*> optionMaybe (keyword TokAlias >> anyStringTok) + +routineImplP = deferred <|> fullRoutineBody + +deferred = do + keyword TokDeferred + return RoutineDefer + +fullRoutineBody :: Parser (RoutineBody Expr) +fullRoutineBody = do + decls <- concat `fmap` option [] (keyword TokLocal >> many decl) + external <|> (do body <- featBody + return (RoutineBody + { routineLocal = decls + , routineBody = body + , routineLocalProcs = [] + } + )) + +featBody :: Parser Stmt +featBody = attachTokenPos $ + (keyword TokDo <|> keyword TokOnce) >> + Block `fmap` stmts diff --git a/Language/Eiffel/Parser/Lex.x b/Language/Eiffel/Parser/Lex.x new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Parser/Lex.x @@ -0,0 +1,526 @@ +{ +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE ScopedTypeVariables #-} +module Language.Eiffel.Parser.Lex + ( Parser + , Token (..) + , SpanToken (..) + , Assoc (..) + , keyword + , identifier + , squares + , comma + , identifierNamed + , colon + , parens + , semicolon + , period + , symbol + , braces + + , arrayStart + , arrayEnd + + , attachTokenPos + + -- , freeOperator + , binOpToken + , opInfo + , opNamed + , opSymbol + + , tokenizer + , tokenizeFile + + , charTok + , stringTok + , anyStringTok + , integerTok + , floatTok + , boolTok + ) + where + +import Control.DeepSeq + +import Data.Char +import qualified Data.Map as Map +import qualified Data.ByteString.Lazy.Char8 as BL +import qualified Data.ByteString.Char8 as BS +import qualified Data.Text as Text +import qualified Data.Text.Encoding as Text +import Data.Text (Text) + +import Language.Eiffel.Position +import Language.Eiffel.Syntax + +import Text.Parsec +import Text.Parsec.Pos +} + +%wrapper "monad-bytestring" + +$digit = 0-9 +$alpha = [a-zA-Z] +$paren = [\(\)\<\>\{\}\[\]] +$symbol = [\, \; \` \' \? \:] +$operator = [\=\<\>\$\&\|\+\-\/\~\*\.\#\^\\\@] +$graphic = $printable # $white +$stringinner = [$graphic '\ ' \t] # \" + +@esc = \% ($printable | \/ $digit+ \/) +@char = $printable | @esc +@eol = \r? \n +@blockstring = \" \[ $white* @eol ($printable | $white)* \] \" +@string = \" ($stringinner | \%. | \%@eol)* \" +@exponent = [eE] [\+\-]? $digit+ +eiffel :- + +<0> $white+ ; +<0> "--" .* ; +<0> \' @char \' { withPos (Char . Text.head . Text.tail . Text.init) } +<0> "and" (\ )* "then" { withPos (opInfoTok AndThen 5 AssocLeft) } +<0> "and" { withPos (opInfoTok And 5 AssocLeft) } +<0> "or" (\ )* "else" { withPos (opInfoTok OrElse 4 AssocLeft) } +<0> "or" { withPos (opInfoTok Or 4 AssocLeft) } +<0> "xor" { withPos (opInfoTok Xor 4 AssocLeft) } +<0> "implies" { withPos (opInfoTok Implies 3 AssocLeft) } + +<0> "ensure" (\ )* "then" { withPos (const TokEnsureThen) } +<0> "require" (\ )* "else"{ withPos (const TokRequireElse) } + +<0> $digit+\.$digit+ @exponent? { withPos (Float . read . Text.unpack) } +<0> 0x[$digit a-f A-F]+ { withPos bsHexToInteger } +<0> $digit+ (\_ $digit+)* { withPos (Integer . read . filter (/= '_') . Text.unpack ) } +<0> $operator+ { withPos operator } +<0> $paren { withPos (Paren . Text.head) } +<0> $alpha[$alpha $digit \_ \']* { withPos lookupIdentifier } +<0> $symbol { withPos (Symbol . Text.head) } +<0> \"\[ { blockStringLex } +<0> @string { withPos (processString . Text.tail . Text.init) } +<0> eof { withPos (tokConst EOF) } +<0> . { withPos (tokConst LexError) } + +{ + +tokenMap :: Map.Map Text Token +tokenMap = + Map.fromList + [("true", TokTrue) + ,("false", TokFalse) + ,("void", TokVoid ) + ,("not", TokNot) + ,("old", TokOld) + ,("agent", TokAgent) + ,("alias", TokAlias) + ,("assign", TokAssign) + ,("across", TokAcross) + ,("attached", TokAttached) + ,("inspect", TokInspect) + ,("when", TokWhen) + ,("if", TokIf) + ,("then", TokThen) + ,("else", TokElse) + ,("elseif", TokElseIf) + ,("from", TokFrom) + ,("until", TokUntil) + ,("loop", TokLoop) + ,("variant", TokVariant) + ,("is", TokIs) + ,("do", TokDo) + ,("end", TokEnd) + ,("once", TokOnce) + ,("retry", TokRetry) + ,("rescue", TokRescue) + ,("external", TokExternal) + ,("obsolete", TokObsolete) + ,("built_in", TokBuiltin) + ,("class", TokClass) + ,("inherit", TokInherit) + ,("note", TokNote) + ,("check", TokCheck) + ,("debug", TokDebug) + ,("create", TokCreate) + ,("convert", TokConvert) + ,("result", TokResult) + ,("current", TokCurrent) + ,("precursor", TokPrecursor) + ,("like", TokLike) + ,("detachable", TokDetachable) + ,("separate", TokSeparate) + ,("frozen", TokFrozen) + ,("expanded", TokExpanded) + ,("feature", TokFeature) + ,("local", TokLocal) + ,("deferred", TokDeferred) + ,("attribute", TokAttribute) + ,("export", TokExport) + ,("redefine", TokRedefine) + ,("rename", TokRename) + ,("select", TokSelect) + ,("undefine", TokUndefine) + ,("all", TokAll) + ,("some", TokSome) + ,("ensure", TokEnsure) + ,("require", TokRequire) + ,("invariant", TokInvariant) + ,("as", TokAs) + ] + +opInfoTok op prec assoc = const $ Operator $ BinOpInfo op prec assoc + +operator txt + | txt == "<<" = ArrayStart + | txt == ">>" = ArrayEnd + | otherwise = + case Map.lookup txt operatorMap of + Just opInf -> Operator opInf + _ -> Operator (BinOpInfo (SymbolOp txt) 11 AssocLeft) + +data Assoc = AssocLeft | AssocRight deriving (Eq, Show) +type Prec = Int + +data BinOpInfo = BinOpInfo !BinOp !Prec !Assoc deriving (Eq, Show) + +operatorMap :: Map.Map Text BinOpInfo +operatorMap = + Map.fromList + [ ("^", BinOpInfo Pow 10 AssocRight) + , ("*", BinOpInfo Mul 9 AssocLeft) + , ("/", BinOpInfo Div 9 AssocLeft) + , ("//", BinOpInfo Quot 9 AssocLeft) + , ("\\\\", BinOpInfo Rem 9 AssocLeft) + , ("+", BinOpInfo Add 8 AssocLeft) + , ("-", BinOpInfo Sub 8 AssocLeft) + , ("<=", BinOpInfo (RelOp Lte NoType) 6 AssocLeft) + , ("<", BinOpInfo (RelOp Lt NoType) 6 AssocLeft) + , ("=", BinOpInfo (RelOp Eq NoType) 6 AssocLeft) + , ("~", BinOpInfo (RelOp TildeEq NoType) 6 AssocLeft) + , ("/=", BinOpInfo (RelOp Neq NoType) 6 AssocLeft) + , ("/~", BinOpInfo (RelOp TildeNeq NoType) 6 AssocLeft) + , (">", BinOpInfo (RelOp Gt NoType) 6 AssocLeft) + , (">=", BinOpInfo (RelOp Gte NoType) 6 AssocLeft) + ] + +tokConst :: a -> Text -> a +tokConst = const + +lookupIdentifier :: Text -> Token +lookupIdentifier x = + let x' = Text.toLower x + in case Map.lookup x' tokenMap of + Just t -> t + Nothing -> Identifier x + +data Token + = Identifier Text + | Symbol Char + | String Text + | BlockString Text + | Char Char + | Paren Char + | ArrayStart + | ArrayEnd + | Operator !BinOpInfo + | Float Double + | Integer Integer + | TokTrue + | TokFalse + | TokVoid + | TokNot + | TokOld + | TokAgent + | TokAlias + | TokAssign + | TokAcross + | TokAttached + | TokInspect + | TokWhen + | TokIf + | TokThen + | TokElse + | TokElseIf + | TokFrom + | TokUntil + | TokLoop + | TokVariant + | TokIs + | TokDo + | TokEnd + | TokOnce + | TokRetry + | TokRescue + | TokExternal + | TokObsolete + | TokBuiltin + | TokClass + | TokInherit + | TokNote + | TokCheck + | TokDebug + | TokCreate + | TokConvert + | TokResult + | TokCurrent + | TokPrecursor + | TokLike + | TokDetachable + | TokSeparate + | TokFrozen + | TokExpanded + | TokFeature + | TokLocal + | TokDeferred + | TokAttribute + | TokExport + | TokRedefine + | TokRename + | TokSelect + | TokUndefine + | TokAll + | TokSome + | TokEnsure + | TokEnsureThen + | TokRequire + | TokRequireElse + | TokInvariant + | TokAs + | EOF + | LexError + deriving (Eq, Show) + +bsToText = Text.decodeUtf8 . BS.concat . BL.toChunks + +withPos :: (Text -> Token) -> AlexInput -> Int -> Alex Token +withPos f (_pos, _last, str) i + = return (f $ bsToText $ ByteString.take (fromIntegral i) str) + +bsHexToInteger bs = Integer $ Text.foldl' go 0 (Text.drop 2 bs) + where + go :: Integer -> Char -> Integer + go !acc !c = acc*16 + fromIntegral (hexDigitToInt c) + + hexDigitToInt :: Char -> Int + hexDigitToInt c + | c >= '0' && c <= '9' = ord c - ord '0' + | c >= 'a' && c <= 'f' = ord c - (ord 'a' - 10) + | otherwise = ord c - (ord 'A' - 10) + +type Parser a = Parsec [SpanToken] () a + +data SpanToken = + SpanToken { spanP :: SourcePos + , spanToken :: Token + } + deriving Show + +instance NFData Token where + rnf !t = () + +instance NFData SpanToken where + rnf (SpanToken !pos !tok) = () + +data BlStrNewL = LineStart | MidLine + +alexGetChar input = + case alexGetByte input of + Just (_, input') -> Just (alexInputPrevChar input', input') + Nothing -> Nothing + +blockStringLex :: AlexInput -> Int -> Alex Token +blockStringLex _ _ = do + input <- alexGetInput + go Text.empty LineStart input + where + err input = alexSetInput input >> return LexError + go :: Text -> BlStrNewL -> AlexInput -> Alex Token + go str isNew input = do + case alexGetChar input of + Nothing -> err input + Just (c, input) -> do + case c of + '\r' -> go (Text.cons c str) LineStart input + '\n' -> go (Text.cons c str) LineStart input + ']' -> case alexGetChar input of + Nothing -> err input + Just (c, input) -> do + case c of + '"' -> case isNew of + LineStart -> alexSetInput input >> + return (BlockString $ Text.reverse str) + _ -> go (Text.append "\"]" str) isNew input + _ -> go (Text.cons c str) isNew input + _ -> if isSpace c + then go (Text.cons c str) isNew input + else go (Text.cons c str) MidLine input + +processString :: Text -> Token +processString str = String str -- -- $ either reverse reverse $ foldl go (Right "") str + -- where go (Right acc) '%' = Left acc + -- go (Right acc) c = Right (c:acc) + -- go (Left acc) c = Right (x:acc) + -- where x = case c of + -- 'N' -> '\n' + -- '"' -> '"' + -- '%' -> '%' + -- 'T' -> '\t' + -- 'R' -> '\r' + -- '\n' -> ' ' + -- 'c' -> '^' + -- o -> error ("processString: didn't catch '" ++ + -- [o] ++ + -- "' in " ++ + -- str) + +alexPosnToPos (AlexPn _ line col) = + newPos "FIXME: Lex.hs, no file" + line + col + +grabToken :: (Token -> Maybe a) -> Parser a +grabToken f = Text.Parsec.token show spanP (f . spanToken) + +opSymbol :: Text +opSymbol = "=<>$&|+-/\\~*.#^@?" + +symbolF s (Symbol sym) + | sym == s = Just () + | otherwise = Nothing +symbolF _ _ = Nothing + +identifier = grabToken f + where f (Identifier i) = Just i + f _ = Nothing + +identifierNamed n = grabToken f + where f (Identifier i) + | n == i = Just i + | otherwise = Nothing + f _ = Nothing + +opNamed op = opInfo (SymbolOp op) +opInfo op = grabToken f + where f (Operator (BinOpInfo op' _ _)) + | op == op' = Just () + | otherwise = Nothing + f _ = Nothing + +arrayStart = keyword ArrayStart +arrayEnd = keyword ArrayEnd + +period = opNamed "." + +symbol = grabToken . symbolF + +semicolon = grabToken (symbolF ';') +comma = grabToken (symbolF ',') +colon = grabToken (symbolF ':') + +langle = opInfo (RelOp Lt NoType) +rangle = opInfo (RelOp Gt NoType) +lbrak = keyword (Paren '{') +rbrak = keyword (Paren '}') +lparen = keyword (Paren '(') +rparen = keyword (Paren ')') +lsquare = keyword (Paren '[') +rsquare = keyword (Paren ']') + +braces = between lbrak rbrak +angles = between langle rangle +squares = between lsquare rsquare +parens = between lparen rparen + +attachTokenPos :: Parser a -> Parser (Pos a) +attachTokenPos p = do + tks <- getInput + case tks of + t:_ -> attachPos (spanP t) `fmap` p + _ -> fail "no more input" + +binOpToken :: Int -> Parser (BinOp, Int, Assoc) +binOpToken prec = grabToken f + where f (Operator (BinOpInfo op prec' assoc)) + | prec' >= prec = Just (op, prec', assoc) + | otherwise = Nothing + f _ = Nothing + +-- freeOperator :: Parser String +-- freeOperator = grabToken nonFree "free operator" +-- where +-- nonFree (Operator op) | not (op `elem` predefinedOps) = Just op +-- nonFree _ = Nothing + +-- wordOps = ["and then", "and", "or else", "or", "implies","xor"] + +-- predefinedOps = concat [ ["*","+","-", "^"] +-- , ["<=",">=","=","/=","~","/~"] +-- , ["<<", ">>"] +-- , ["<",">"] +-- , ["\"[","]\""] +-- , [":=","?=","{","}"] +-- , wordOps +-- ] + +type AlexUserState = String + +anyStringTok = stringTok <|> blockStringTok + +blockStringTok = grabToken f + where f (BlockString s) = Just s + f _ = Nothing + +stringTok = grabToken f + where f (String s) = Just s + f _ = Nothing + +charTok = grabToken f + where f (Char c) = Just c + f _ = Nothing + +boolTok = grabToken f + where f TokTrue = Just True + f TokFalse = Just False + f _ = Nothing + +integerTok = grabToken f + where f (Integer i) = Just i + f _ = Nothing + +floatTok = grabToken f + where f (Float d) = Just d + f _ = Nothing + + +keyword t = grabToken f >> return () + where f t' + | t == t' = Just Text.unpack + | otherwise = Nothing + +ignorePendingBytes :: AlexInput -> AlexInput +ignorePendingBytes p = p + +alexInitUserState = "" + +alexEOF :: Alex Token +alexEOF = return EOF + +runTokenizer file str = runAlex str $ + let loop ts = do + tok <- alexMonadScan + (AlexPn _ line col, _lastChar, _string) <- alexGetInput + case tok of + EOF -> return (reverse ts) + LexError -> error ("lexer error: " ++ show (newPos file line col)) + _ -> loop (SpanToken (newPos file line col) tok:ts) + in loop [] + +tokenizer :: String -> Text -> Either String [SpanToken] +tokenizer file txt = runTokenizer file (BL.fromChunks [Text.encodeUtf8 txt]) + +tokenizeFile :: String -> IO (Either String [SpanToken]) +tokenizeFile file = do + s <- BL.readFile file + return $ runTokenizer file s + +} diff --git a/Language/Eiffel/Parser/Note.hs b/Language/Eiffel/Parser/Note.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Parser/Note.hs @@ -0,0 +1,20 @@ +module Language.Eiffel.Parser.Note where + +import Control.Applicative hiding ((<|>), optional) + +import Language.Eiffel.Syntax +import Language.Eiffel.Parser.Lex +import Language.Eiffel.Parser.Expr + +import Text.Parsec + +note :: Parser [Note] +note = keyword TokNote >> many1 noteEntry + +noteEntry :: Parser Note +noteEntry = Note <$> (identifier <* colon) + <*> noteItem `sepBy1` comma + <* optional semicolon + +noteItem :: Parser UnPosExpr +noteItem = VarOrCall <$> identifier <|> manifest diff --git a/Language/Eiffel/Parser/Statement.hs b/Language/Eiffel/Parser/Statement.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Parser/Statement.hs @@ -0,0 +1,170 @@ +{-# LANGUAGE ScopedTypeVariables #-} + +module Language.Eiffel.Parser.Statement where + +import qualified Data.Text as Text + +import Language.Eiffel.Syntax +import Language.Eiffel.Parser.Clause +import Language.Eiffel.Parser.Expr +import Language.Eiffel.Parser.Lex +import Language.Eiffel.Parser.Typ + +import Text.Parsec + +-- stmt :: Parser Stmt +stmt = attachTokenPos bareStmt + +-- bareStmt :: Parser UnPosStmt +bareStmt = do + s <- choice [ across + , assign + , assignAttempt + , check + , retry + , create + , ifStmt + , inspect + , loop + , debug + , try callStmt + ] + optional semicolon + return s +stmts :: Parser [Stmt] +stmts = many stmt + +stmts' = many bareStmt + +retry = do + keyword TokRetry + return Retry + +across = do + keyword TokAcross + e <- expr + keyword TokAs + i <- identifier + keyword TokLoop + bl <- blockPos + keyword TokEnd + return (Across e i bl) + +inspect = + let whenPart = do + keyword TokWhen + es <- expr `sepBy1` comma + s <- attachTokenPos (keyword TokThen >> Block `fmap` stmts) + return (es, s) + in do + keyword TokInspect + e <- expr + whens <- many1 whenPart + elseMb <- optionMaybe (attachTokenPos $ keyword TokElse >> Block `fmap` stmts) + keyword TokEnd + return $ Inspect e whens elseMb + +check = do + keyword TokCheck + clauses <- many clause + let chk = keyword TokEnd >> return (Check clauses) + checkBlock = do + keyword TokThen + body <- blockPos + keyword TokEnd + return (CheckBlock clauses body) + checkBlock <|> chk + + +blockPos = attachTokenPos block + +block :: Parser UnPosStmt +block = fmap Block stmts + +ifStmt :: Parser UnPosStmt +ifStmt = do + b <- keyword TokIf >> expr + body <- attachTokenPos (keyword TokThen >> fmap Block stmts) + ifelses <- many ifelseP + elseMb <- optionMaybe elseP + elseMb' <- maybe (return Nothing) (fmap Just . attachTokenPos . return) elseMb + keyword TokEnd + return (If b body ifelses elseMb') + +-- elsePart :: Parser UnPosStmt +-- elsePart = ifelseP <|> elseP + +elseP :: Parser UnPosStmt +elseP = keyword TokElse >> fmap Block stmts + +ifelseP :: Parser (ElseIfPart Expr) +ifelseP = do + b <- keyword TokElseIf >> expr + s1 <- attachTokenPos $ keyword TokThen >> fmap Block stmts + -- s2 <- attachTokenPos $ option (Block []) elsePart + return (ElseIfPart b s1) + +create :: Parser UnPosStmt +create = do + keyword TokCreate + t <- optionMaybe (braces typ) + v <- attachTokenPos var + s <- (do + period + callE <- call + case callE of + UnqualCall fName args -> return (Create t v fName args) + VarOrCall fName -> return (Create t v fName []) + e -> error $ "create: should not have parsed " ++ show e + ) <|> return (Create t v defaultCreate []) + return s + +loop :: Parser UnPosStmt +loop = do + keyword TokFrom + fr <- attachTokenPos block + invarMb <- option [] (keyword TokInvariant >> many clause) + un <- keyword TokUntil >> expr + lo <- attachTokenPos $ keyword TokLoop >> block + variant <- optionMaybe (keyword TokVariant >> clauseExpr `fmap` clause) + keyword TokEnd + return (Loop fr invarMb un lo variant) + +assignId :: Parser Expr +assignId = do + e <- expr + colon + opInfo (RelOp Eq NoType) + return e + +assignAttemptId :: Parser Expr +assignAttemptId = do + i <- attachTokenPos var + symbol '?' + opInfo (RelOp Eq NoType) + return i + +callStmt :: Parser UnPosStmt +callStmt = do + c <- attachTokenPos call + return $ CallStmt c + +assign :: Parser UnPosStmt +assign = do + i <- try assignId + e <- expr "assignment expression" + return $ Assign i e + +assignAttempt :: Parser UnPosStmt +assignAttempt = do + i <- try assignAttemptId + e <- expr "assignment attempt expression" + return $ AssignAttempt i e + +debug :: Parser UnPosStmt +debug = do + keyword TokDebug + str <- option Text.empty (parens anyStringTok) + b <- attachTokenPos block + keyword TokEnd + return (Debug str b) diff --git a/Language/Eiffel/Parser/Statement.hs-boot b/Language/Eiffel/Parser/Statement.hs-boot new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Parser/Statement.hs-boot @@ -0,0 +1,6 @@ +module Language.Eiffel.Parser.Statement where + +import Language.Eiffel.Parser.Lex +import Language.Eiffel.Syntax + +stmt :: Parser Stmt diff --git a/Language/Eiffel/Parser/Typ.hs b/Language/Eiffel/Parser/Typ.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Parser/Typ.hs @@ -0,0 +1,71 @@ +{-# LANGUAGE OverloadedStrings #-} +module Language.Eiffel.Parser.Typ where + +import Control.Applicative ((<$>)) + +import Data.Text (Text) + +import Language.Eiffel.Syntax +import Language.Eiffel.Parser.Lex + +import Text.Parsec + +likeTyp :: Parser Typ +likeTyp = keyword TokLike >> + Like `fmap` (identifier <|> (keyword TokCurrent >> return "Current")) + +classTyp :: Parser Typ +classTyp = do + i <- identifier + let i' = case i of + "INTEGER" -> "INTEGER_32" + "CHARACTER" -> "CHARACTER_8" + "REAL" -> "REAL_32" + "STRING" -> "STRING_8" + x -> x + gs <- option [] (squares (typ `sepBy1` comma)) + return (ClassType i' gs) + +tupleTyp :: Parser Typ +tupleTyp = do + identifierNamed "TUPLE" + let typeDeclP = + Right <$> concat <$> try (decl `sepBy1` semicolon) <|> + Left <$> (typ `sepBy1` comma) + typeOrDecls <- option (Left []) (squares typeDeclP) + return (TupleType typeOrDecls) + +detTyp :: Parser Typ +detTyp = keyword TokDetachable >> (sepTyp <|> likeTyp <|> baseTyp) + +attTyp :: Parser Typ +attTyp = keyword TokAttached >> (likeTyp <|> baseTyp) + +typ :: Parser Typ +typ = detTyp <|> attTyp <|> likeTyp <|> sepTyp <|> baseTyp + +baseTyp :: Parser Typ +baseTyp = tupleTyp <|> classTyp + +sepTyp :: Parser Typ +sepTyp = do + keyword TokSeparate + p <- return Nothing -- optionMaybe (angles procGen) + ps <- return [] -- option [] procGens + cn <- identifier + return $ Sep p ps cn + +decl :: Parser [Decl] +decl = do + names <- identifier `sepBy1` comma "Declaration identifier" + decl' names + +decl' :: [Text] -> Parser [Decl] +decl' varNames = do + colon "Declaration ':'" + typeName <- typ "Declaration type" + return $ map (flip Decl typeName) varNames + +argumentList :: Parser [Decl] +argumentList = + option [] (concat `fmap` parens (decl `sepBy` optional semicolon)) diff --git a/Language/Eiffel/Position.hs b/Language/Eiffel/Position.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Position.hs @@ -0,0 +1,90 @@ +{-# LANGUAGE TemplateHaskell #-} + +module Language.Eiffel.Position + (Pos (..) + ,Line + ,Column + ,SourcePos + + ,sourceLine + ,sourceColumn + ,sourceName + + ,inheritPos + + ,attachPos + ,attachPosM + ,attachEmptyPos + ,attachPosBefore + ,attachPosHere + + ,takePos + + ,position + ,contents + ) where + +import Control.Monad + +import Data.DeriveTH +import Data.Binary +import Control.DeepSeq + +import Text.Parsec +import Text.Parsec.Pos +import Text.Parsec.ByteString + +data Pos a = Pos SourcePos a deriving Ord + +instance Eq a => Eq (Pos a) where + (==) p1 p2 = contents p1 == contents p2 + +instance Show a => Show (Pos a) where + show p = -- show (position p) ++ "> " ++ + show (contents p) + +instance Functor Pos where + fmap f (Pos s a) = Pos s (f a) + +inheritPos :: (Pos a -> b) -> Pos a -> Pos b +inheritPos f a = attachPos (position a) (f a) + +takePos :: Pos a -> b -> Pos b +takePos pa b = attachPos (position pa) b + +attachEmptyPos = attachPos (initialPos "") + +attachPos :: SourcePos -> a -> Pos a +attachPos = Pos + +attachPosM :: Monad m => m SourcePos -> m a -> m (Pos a) +attachPosM = liftM2 attachPos + +attachPosHere :: a -> Parser (Pos a) +attachPosHere a = flip attachPos a `fmap` getPosition + +attachPosBefore :: Parser a -> Parser (Pos a) +attachPosBefore = attachPosM getPosition + +position :: Pos a -> SourcePos +position (Pos p _) = p + +contents :: Pos a -> a +contents (Pos _ a) = a + +instance Binary SourcePos where + get = return (newPos "filename lost" 0 0) + put _p = return () + +-- instance Binary SourcePos where +-- get = do (line, col, name) <- get +-- return (newPos name line col) + +-- put p = put (sourceLine p, sourceColumn p, sourceName p) + +$( derive makeBinary ''Pos ) + +instance NFData SourcePos where + rnf p = sourceLine p `seq` sourceColumn p `seq` sourceName p `seq` () + +$( derive makeNFData ''Pos ) diff --git a/Language/Eiffel/PrettyPrint.hs b/Language/Eiffel/PrettyPrint.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/PrettyPrint.hs @@ -0,0 +1,513 @@ +{-# LANGUAGE OverloadedStrings #-} +module Language.Eiffel.PrettyPrint where + +import Control.Lens hiding (to, lens, from, assign, op) + +import Data.Hashable +import qualified Data.HashMap.Strict as Map +import qualified Data.Set as Set +import Data.Set (Set) +import qualified Data.Text as Text +import Data.Text (Text) + +import Text.PrettyPrint + +import Language.Eiffel.Syntax +import Language.Eiffel.Position + +ttext = text . Text.unpack + +defaultIndent = 2 +nestDef = nest defaultIndent + +renderWithTabs = fullRender (mode style) (lineLength style) (ribbonsPerLine style) spacesToTabs "" + where + spacesToTabs :: TextDetails -> String -> String + spacesToTabs (Chr c) s = c:s + spacesToTabs (Str s1) s2 = spaceAppend s1 s2 + spacesToTabs (PStr s1) s2 = spaceAppend s1 s2 + + spaceAppend s1 s2 = + if s1 == replicate (length s1) ' ' && length s1 > 1 + then replicate (length s1 `div` defaultIndent) '\t' ++ s2 + else s1 ++ s2 + +newline = char '\n' +emptyLine = text "" + +ups = Text.toUpper + +toDoc :: Clas -> Doc +toDoc = toDocWith False routineBodyDoc + +toInterfaceDoc :: ClasInterface -> Doc +toInterfaceDoc = toDocWith True interfaceBodyDoc + +interfaceBodyDoc :: EmptyBody -> Doc +interfaceBodyDoc = const (text "do") + +toDocWith fullAttr bodyDoc c = + let defer = if deferredClass c then text "deferred" else empty + froz = if frozenClass c then text "frozen" else empty + expnd = if expandedClass c then text "expanded" else empty + in vsep [ notes (classNote c) $+$ (if null (classNote c) then empty else emptyLine) + , defer <+> froz <+> expnd <+> text "class" + , nestDef (ttext (ups $ className c)) <+> genericsDoc (generics c) <+> procGenDoc (procGeneric c) + , emptyLine + , inheritance (inherit c) + , vsep (map createClause (creates c)) + , convertClause (converts c) + , vsep (featureClauses fullAttr bodyDoc (featureMap c)) + , invars (invnts c) + , text "end" + ] + + +inheritance is = vsep (map inheritanceClauses is) + +inheritanceClauses (Inheritance nonConform cs) = + let conformMark | nonConform = text "{NONE}" + | otherwise = empty + in (text "inherit" <+> conformMark) $+$ nestDef (vsep (map inheritClause cs)) + +inheritClause (InheritClause cls renames exports undefs redefs selects) = + let renameDoc (Rename orig new alias) = + ttext orig <+> text "as" <+> ttext new <+> + maybe empty (\a -> text "alias" <+> doubleQuotes (ttext a)) alias + exportListDoc (ExportFeatureNames l) = vCommaSep (map ttext l) + exportListDoc ExportAll = text "all" + exportDoc (Export to what) = + braces (commaSep (map ttext to)) $+$ nestDef (exportListDoc what) + in type' cls $+$ nestDef (vsep + [ text "rename" $?$ nestDef (vCommaSep (map renameDoc renames)) + , text "export" $?$ nestDef (vsep (map exportDoc exports)) + , text "undefine" $?$ nestDef (vCommaSep (map ttext undefs)) + , text "redefine" $?$ nestDef (vCommaSep (map ttext redefs)) + , text "select" $?$ nestDef (vCommaSep (map ttext selects)) + , if null renames && null exports && null undefs && null redefs && null selects + then empty else text "end" + , emptyLine + ]) + +createClause (CreateClause exports names) = + let exps = if null exports + then empty + else braces (commaSep (map ttext exports)) + in (text "create" <+> exps) $+$ nestDef (commaSep (map ttext names)) $+$ emptyLine + +convertClause [] = empty +convertClause convs = + let go (ConvertFrom fname ts) = ttext fname <+> + parens (braces (commaSep (map type' ts))) + go (ConvertTo fname ts) = ttext fname <> colon <+> + braces (commaSep (map type' ts)) + in text "convert" $+$ nestDef (vCommaSep (map go convs)) $+$ emptyLine + +featureClauses :: (Ord body) + => Bool + -> (body -> Doc) + -> FeatureMap body Expr + -> [Doc] +featureClauses fullAttr bodyDoc featMap = + concat [ allExports fmRoutines routDoc' + , allExports fmAttrs attrDoc' + , allExports fmConsts constDoc' + ] + where + insertExport expMap (ExportedFeature exports feat) = + Map.insertWith Set.union exports (Set.singleton feat) expMap + exportMap lens = Map.foldl' insertExport Map.empty (view lens featMap) + exportDoc exports + | Set.null exports = empty + | otherwise = braces (commaSep (map ttext $ Set.toList exports)) + + routDoc' r = routineDoc bodyDoc r $+$ emptyLine + attrDoc' a = attrDoc fullAttr a $+$ emptyLine + constDoc' c = constDoc c $+$ emptyLine + + printExports featDoc exports someFeats = + vsep [ text "feature" <+> exportDoc exports + , emptyLine + , nestDef $ vsep $ map featDoc $ Set.toList someFeats + ] + + allExports lens featDoc = + map (uncurry $ printExports featDoc) $ Map.toList (exportMap lens) + +vsep = foldr ($+$) empty +commaSep = hsep . punctuate comma +vCommaSep = vsep . punctuate comma +angles d = langle <> d <> rangle +langle = char '<' +rangle = char '>' +squareQuotes t = text "\"[" <> t <> text "]\"" + +anyStringLiteral s + | Text.isPrefixOf "\n" s = squareQuotes $ ttext s + | Text.isPrefixOf "\r\n" s = squareQuotes $ ttext s + | otherwise = doubleQuotes $ stringLiteral s + + +stringLiteral s = ttext s' + where s' = go' s + go' = go . Text.uncons + go (Just ('\n', cs)) = Text.append "%N" $ go' cs + go (Just ('\r', cs)) = Text.append "%R" $ go' cs + go (Just ('\t', cs)) = Text.append "%T" $ go' cs + go (Just ('"', cs)) = Text.append "%\"" $ go' cs + go (Just (c, cs)) = Text.cons c (go' cs) + go Nothing = Text.empty + +procDoc (Proc s) = ttext s +procDoc Dot = text "" + +genericsDoc [] = empty +genericsDoc gs = brackets (commaSep (map go gs)) + where go (Generic name constr createsMb) = + ttext name <+> constraints constr <+> maybe empty create createsMb + constraints [] = empty + constraints [t] = text "->" <+> type' t + constraints ts = text "->" <+> braces (commaSep (map type' ts)) + create cs = hsep [ text "create" + , commaSep (map ttext cs) + , text"end" + ] + +notes [] = empty +notes ns = vsep [ text "note" + , nestDef (vsep $ map note ns) + ] + +note (Note tag content) = ttext tag <> colon <+> commaSep (map (expr' 0) content) + +invars is = text "invariant" $?$ clausesDoc is + + +procGenDoc [] = empty +procGenDoc ps = go ps + where go = angles . hsep . punctuate comma . map procDoc + +decl :: Decl -> Doc +decl (Decl label typ) = ttext label <> typeDoc typ + +typeDoc NoType = empty +typeDoc t = text ":" <+> type' t + +frozen b = if b then text "frozen" else empty + +require (Contract inh c) = (if inh then text "require else" else text "require") $?$ clausesDoc c +ensure (Contract inh c) = (if inh then text "ensure then" else text "ensure") $?$ clausesDoc c + +constDoc :: Constant Expr -> Doc +constDoc (Constant froz d val) = frozen froz <+> decl d <+> text "=" <+> expr val + +attrDoc :: Bool -> Attribute Expr -> Doc +attrDoc fullAttr (Attribute froz d assn ns reqs ens) = + frozen froz <+> decl d <+> assignText assn $+$ + nestDef (vsep [ notes ns + , require reqs + , attrKeyword + , ensure ens + , endKeyword + ]) + where assignText Nothing = empty + assignText (Just a) = text "assign" <+> ttext a + hasBody = not (null (contractClauses ens) && null (contractClauses reqs) && null ns) + attrKeyword | hasBody || fullAttr = text "attribute" + | otherwise = empty + endKeyword | hasBody || fullAttr = text "end" + | otherwise = empty + +type' :: Typ -> Doc +type' (ClassType str gens) = ttext (ups str) <+> genDoc gens +type' VoidType = text "NONE" +type' (Like s) = text "like" <+> ttext s +type' NoType = empty +type' (Sep mP ps str) = sepDoc <+> procM mP <+> procs ps <+> ttext str +type' (TupleType typeDecls) = + let typeArgs = + case typeDecls of + Left types -> commaSep (map type' types) + Right decls -> hcat (punctuate (text ";") (map decl decls)) + tupleGen | isEmpty typeArgs = empty + | otherwise = text "[" <> typeArgs <> text "]" + in text "TUPLE" <+> tupleGen + +routineDoc :: (body -> Doc) -> AbsRoutine body Expr -> Doc +routineDoc bodyDoc f + = let header = frozen (routineFroz f) <+> + ttext (routineName f) <+> + alias <+> + formArgs (routineArgs f) <> + typeDoc (routineResult f) <+> + procs (routineProcs f) + alias = + case routineAlias f of + Nothing -> empty + Just name -> text "alias" <+> doubleQuotes (ttext name) + assign = + case routineAssigner f of + Nothing -> empty + Just name -> text "assign" <+> ttext name + rescue = + case routineRescue f of + Nothing -> empty + Just stmts -> text "rescue" $+$ + nestDef (vsep $ map stmt stmts) + in header <+> assign $+$ + (nestDef $ vsep + [ notes (routineNote f) + , require (routineReq f) + , text "require-order" $?$ nestDef (procExprs f) + , text "lock" $?$ nestDef (locks (routineEnsLk f)) + , bodyDoc $ routineImpl f + , ensure (routineEns f) + , rescue + , text "end" + ] + ) + +routineBodyDoc RoutineDefer = text "deferred" +routineBodyDoc (RoutineExternal s aliasMb) = + vcat [ text "external" + , nestDef (anyStringLiteral s) + , text "alias" $?$ maybe empty anyStringLiteral aliasMb + ] +routineBodyDoc ft = vsep [ locals ft + , text "do" + , nestDef $ stmt $ routineBody ft + ] + +locals ft = text "local" $?$ nestDef (vsep $ map decl (routineLocal ft)) + +procExprs = vCommaSep . map procExprD . routineReqLk + +($?$) :: Doc -> Doc -> Doc +($?$) l e + | isEmpty e = empty + | otherwise = l $+$ e + +() :: Doc -> Doc -> Doc +() l e + | isEmpty e = empty + | otherwise = l e + + +clausesDoc :: [Clause Expr] -> Doc +clausesDoc cs = nestDef (vsep $ map clause cs) + +clause :: Clause Expr -> Doc +clause (Clause nameMb e) = maybe empty (\n -> ttext n <> colon) nameMb <+> expr e + +stmt = stmt' . contents + +stmt' (Assign l e) = expr l <+> text ":=" <+> expr e +stmt' (AssignAttempt l e) = expr l <+> text "?=" <+> expr e +stmt' (CallStmt e) = expr e +stmt' (If cond body elseParts elseMb) = + let elsePart = case elseMb of + Just elsee -> vsep [text "else", nestDef (stmt elsee)] + Nothing -> empty + elseifPart (ElseIfPart c s) = + vsep [ text "elseif" <+> expr c <+> text "then" + , nestDef (stmt s) + ] + elseifParts es = vsep (map elseifPart es) + in vsep [ text "if" <+> expr cond <+> text "then" + , nestDef (stmt body) + , elseifParts elseParts + , elsePart + , text "end" + ] +stmt' (Inspect e whens elseMb) = + let elsePart = case elseMb of + Nothing -> empty + Just s -> text "else" $+$ nestDef (stmt s) + whenParts (es', s) = + (text "when" <+> commaSep (map expr es') <+> text "then") $+$ + nestDef (stmt s) + in vsep [ text "inspect" <+> expr e + , vsep (map whenParts whens) + , elsePart + , text "end" + ] +stmt' (Across e asIdent body) = + vcat [ text "across" + , nestDef (expr e <+> text "as" <+> ttext asIdent) + , text "loop" + , nestDef (stmt body) + , text "end" + ] +stmt' (BuiltIn) = text "builtin" +stmt' (Create t tar n es) = text "create" <+> maybe empty (braces . type') t <+> + if n == defaultCreate then expr tar else expr' 0 (QualCall tar n es) +stmt' (Block ss) = vsep (map stmt ss) +stmt' (Check cs) = vsep [ text "check" + , nestDef (vsep (map clause cs)) + , text "end" + ] +stmt' (CheckBlock cs body) = + vsep [ text "check" <+> vsep (map clause cs) <+> text "then" + , stmt body + , text "end" + ] +stmt' (Loop from invs cond loop var) = + vsep [ text "from" + , nestDef (stmt from) + , text "invariant" $?$ clausesDoc invs + , text "until" + , nestDef (expr cond) + , text "loop" + , nestDef (stmt loop) + , text "variant" $?$ maybe empty (nestDef . expr) var + , text "end" + ] +stmt' (Debug str body) = + vsep [ text "debug" <+> (if Text.null str + then empty + else (parens . anyStringLiteral) str) + , nestDef (stmt body) + , text "end" + ] +stmt' Retry = text "retry" +stmt' s = error ("PrettyPrint.stmt': " ++ show s) + +expr = exprPrec 0 + +exprPrec :: Int -> Expr -> Doc +exprPrec i = expr' i . contents + +expr' _ (UnqualCall n es) = ttext n <+> actArgs es +expr' _ (QualCall t n es) = target <> ttext n <+> actArgs es + where + target = case contents t of + CurrentVar -> empty + _ -> exprPrec 13 t <> char '.' +expr' _ (PrecursorCall cname es) = + text "Precursor" <+> maybe empty (braces . ttext) cname <+> actArgs es +expr' i (AcrossExpr e as q body) = + hsep [ text "across" + , exprPrec i e + , text "as" + , ttext as + , quant q + , expr body + , text "end" + ] +expr' i (UnOpExpr uop e) = condParens (i > 12) $ ttext (unop uop) <+> exprPrec 12 e +expr' i (Lookup targ args) = case targ of + Pos _ (Lookup _ _) -> parens (exprPrec i targ) <+> brackets (commaSep (map expr args)) + _ -> exprPrec i targ <+> brackets (commaSep (map expr args)) +expr' i (BinOpExpr (SymbolOp op) e1 e2) + | op == "[]" = exprPrec i e1 <+> brackets (expr e2) + | otherwise = condParens (i > 11) + (exprPrec 11 e1 <+> ttext op <+> exprPrec 12 e2) +expr' i (BinOpExpr bop e1 e2) = + condParens (i > p) + (exprPrec lp e1 <+> ttext op <+> exprPrec rp e2) + where (op, p) = binop bop + lp = p + rp = p + 1 +expr' _ (Attached t e asVar) = + text "attached" <+> maybe empty (braces . type') t <+> + expr e <+> maybe empty (\s -> text "as" <+> ttext s) asVar +expr' _ (CreateExpr t n es) = + text "create" <+> braces (type' t) <> if n == defaultCreate then empty else char '.' <> ttext n <+> actArgs es +expr' _ (StaticCall t i args) = + braces (type' t) <> char '.' <> ttext i <+> actArgs args +expr' _ (LitArray es) = text "<<" <+> commaSep (map expr es) <+> text ">>" +expr' _ (ManifestCast t e) = braces (type' t) <+> expr e +expr' _ (OnceStr s) = text "once" <+> ttext s +expr' _ (Address e) = text "$" <> expr e +expr' _ (VarOrCall s) = ttext s +expr' _ ResultVar = text "Result" +expr' _ CurrentVar = text "Current" +expr' _ LitVoid = text "Void" +expr' i (LitChar c) = condParens (i >= 13) $ quotes (char c) +expr' i (LitString s) = condParens (i >= 13) $ anyStringLiteral s +expr' i (LitInt int') = condParens (i >= 13) $ integer int' +expr' i (LitBool b) = condParens (i >= 13) $ text (show b) +expr' i (LitDouble d) = condParens (i >= 13) $ double d +expr' i (LitType t) = condParens (i >= 13) $ braces (type' t) +expr' _ (Tuple es) = brackets (hcat $ punctuate comma (map expr es)) +expr' _ (Agent e) = text "agent" <+> case contents e of + QualCall t n es -> case contents t of + VarOrCall _name -> expr e + _ -> parens (expr t) <> char '.' <> ttext n <+> actArgs es + _ -> expr e +expr' _ (InlineAgent ds resMb ss args) = + let decls = formArgs ds + res = maybe empty (\t -> colon <+> type' t) resMb + in vsep [ text "agent" <+> decls <+> res + , text "do" + , nestDef $ vsep (map stmt ss) + , text "end" <+> condParens (not $ null args) + (commaSep (map expr args)) + ] +expr' _ s = error ("expr': " ++ show s) + +quant All = text "all" +quant Some = text "some" + +condParens True e = parens e +condParens False e = e + +unop Neg = "-" +unop Not = "not" +unop Old = "old" + +opList = [ (Pow, ("^", 10)) + , (Mul, ("*", 9)) + , (Div, ("/", 9)) + , (Quot, ("//", 9)) + , (Rem, ("\\\\", 9)) + , (Add, ("+", 8)) + , (Sub, ("-", 8)) + , (And, ("and", 5)) + , (AndThen, ("and then", 5)) + , (Or, ("or", 4)) + , (Xor, ("xor", 4)) + , (OrElse, ("or else", 4)) + , (Implies, ("implies", 3)) + ] + +binop :: BinOp -> (Text, Int) +binop (SymbolOp o) = (o, 11) +binop (RelOp r _) = (relop r, 6) +binop o = + case lookup o opList of + Just (n,p) -> (n,p) + Nothing -> error "binop: could not find operator" + +relop Lt = "<" +relop Lte = "<=" +relop Gt = ">" +relop Gte = ">=" +relop Eq = "=" +relop Neq = "/=" +relop TildeEq = "~" +relop TildeNeq = "/~" + +actArgs [] = empty +actArgs es = parens $ hsep $ punctuate comma (map expr es) + +formArgs [] = empty +formArgs ds = parens $ hsep $ punctuate semi (map decl ds) + +genDoc :: [Typ] -> Doc +genDoc [] = empty +genDoc ps = brackets $ hcat $ punctuate comma (map type' ps) + +procExprD (LessThan a b) = proc a <+> langle <+> proc b +locks [] = empty +locks ps = hsep $ punctuate comma (map proc ps) + +procs [] = empty +procs ps = angles $ locks ps +proc (Proc p) = ttext p +proc Dot = text "dot_proc" +procM = maybe empty (angles . proc) +sepDoc = text "separate" + +instance Hashable a => Hashable (Set a) where + hashWithSalt salt v = hashWithSalt salt (Set.toAscList v) diff --git a/Language/Eiffel/Summary.hs b/Language/Eiffel/Summary.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Summary.hs @@ -0,0 +1,32 @@ +module Language.Eiffel.Summary where + +import qualified Data.ByteString.Char8 as B + +import Data.Binary + +import Language.Eiffel.Syntax +import Language.Eiffel.Parser.Class +import qualified Language.Eiffel.Parser.Lex as L +import Language.Eiffel.Parser +import Language.Eiffel.PrettyPrint + +import Text.Parsec + +import System.IO + +summaryP :: L.Parser [ClasInterface] +summaryP = many clasInterfaceP + +parseSummary :: String -> IO (Either ParseError [ClasInterface]) +parseSummary fileName = lexThenParseFromFile summaryP fileName + +writeSummary :: FilePath -> [ClasInterface] -> IO () +writeSummary filePath ifaces = + withFile filePath WriteMode $ \ hdl -> + mapM_ (B.hPutStrLn hdl . B.pack . show . toInterfaceDoc) ifaces + +readBinarySummary :: String -> IO [ClasInterface] +readBinarySummary = decodeFile + +writeBinarySummary :: String -> [ClasInterface] -> IO () +writeBinarySummary = encodeFile diff --git a/Language/Eiffel/Syntax.hs b/Language/Eiffel/Syntax.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Syntax.hs @@ -0,0 +1,497 @@ +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE OverloadedStrings #-} +module Language.Eiffel.Syntax where + +import Control.DeepSeq +import Control.Lens hiding (op) + +import Data.List +import Data.Hashable +import qualified Data.HashMap.Strict as Map +import Data.HashMap.Strict (HashMap) +import Data.Set (Set) +import qualified Data.Text.Encoding as Text +import Data.Text (Text) +import Data.DeriveTH +import Data.Binary + +import qualified GHC.Generics as G + +import Language.Eiffel.Position + +type Map = HashMap + +type Clas = ClasBody Expr +type ClasBody exp = AbsClas (RoutineBody exp) exp +type ClasInterface = AbsClas EmptyBody Expr +type ClasI exp = AbsClas (RoutineBody exp) exp + +data AbsClas body exp = + AbsClas + { + frozenClass :: Bool, + expandedClass :: Bool, + deferredClass :: Bool, + classNote :: [Note], + className :: ClassName, + currProc :: Proc, + procGeneric :: [Proc], + procExpr :: [ProcDecl], + generics :: [Generic], + obsoleteClass :: Bool, + inherit :: [Inheritance], + creates :: [CreateClause], + converts :: [ConvertClause], + featureMap :: FeatureMap body exp, + invnts :: [Clause exp] + } deriving (Eq, Show) + +data FeatureMap body exp = + FeatureMap + { _fmRoutines :: !(Map Text (ExportedFeature (AbsRoutine body exp))) + , _fmAttrs :: Map Text (ExportedFeature (Attribute exp)) + , _fmConsts :: Map Text (ExportedFeature (Constant exp)) + } deriving (Show, Eq) + +data ExportedFeature feat = + ExportedFeature { _exportClass :: Set Text + , _exportFeat :: !feat + } deriving (Eq, Ord, Show) + +data SomeFeature body exp + = SomeRoutine (AbsRoutine body exp) + | SomeAttr (Attribute exp) + | SomeConst (Constant exp) + deriving (Eq, Show, Ord) + +data Inheritance + = Inheritance + { inheritNonConform :: Bool + , inheritClauses :: [InheritClause] + } deriving (Show, Eq) + +data InheritClause + = InheritClause + { inheritClass :: Typ + , rename :: [RenameClause] + , export :: [ExportClause] + , undefine :: [Text] + , redefine :: [Text] + , select :: [Text] + } deriving (Show, Eq) + +data RenameClause = + Rename { renameOrig :: Text + , renameNew :: Text + , renameAlias :: Maybe Text + } deriving (Show, Eq) + +data ExportList = ExportFeatureNames [Text] | ExportAll deriving (Show, Eq) + +data ExportClause = + Export { exportTo :: [ClassName] + , exportWhat :: ExportList + } deriving (Show, Eq) + +data Generic = + Generic { genericName :: ClassName + , genericConstType :: [Typ] + , genericCreate :: Maybe [Text] + } deriving (Show, Eq) + +data CreateClause = + CreateClause { createExportNames :: [ClassName] + , createNames :: [Text] + } deriving (Show, Eq) + +data ConvertClause = ConvertFrom Text [Typ] + | ConvertTo Text [Typ] deriving (Show, Eq) + +data FeatureClause body exp = + FeatureClause { exportNames :: [ClassName] + , routines :: [AbsRoutine body exp] + , attributes :: [Attribute exp] + , constants :: [Constant exp] + } deriving (Show, Eq) + +type RoutineI = AbsRoutine EmptyBody Expr +type RoutineWithBody exp = AbsRoutine (RoutineBody exp) exp +type Routine = RoutineWithBody Expr + +data EmptyBody = EmptyBody deriving (Show, Eq, Ord) + +data Contract exp = + Contract { contractInherited :: Bool + , contractClauses :: [Clause exp] + } deriving (Show, Eq, Ord) + +data AbsRoutine body exp = + AbsRoutine + { routineFroz :: !Bool + , routineName :: !Text + , routineAlias :: Maybe Text + , routineArgs :: [Decl] + , routineResult :: Typ + , routineAssigner :: Maybe Text + , routineNote :: [Note] + , routineProcs :: [Proc] + , routineReq :: Contract exp + , routineReqLk :: [ProcExpr] + , routineImpl :: !body + , routineEns :: Contract exp + , routineEnsLk :: [Proc] + , routineRescue :: Maybe [PosAbsStmt exp] + } deriving (Show, Eq, Ord) + +data RoutineBody exp + = RoutineDefer + | RoutineExternal Text (Maybe Text) + | RoutineBody + { routineLocal :: [Decl] + , routineLocalProcs :: [ProcDecl] + , routineBody :: PosAbsStmt exp + } deriving (Show, Eq, Ord) + +data Attribute exp = + Attribute { attrFroz :: Bool + , attrDecl :: Decl + , attrAssign :: Maybe Text + , attrNotes :: [Note] + , attrReq :: Contract exp + , attrEns :: Contract exp + } deriving (Show, Eq, Ord) + +data Constant exp = + Constant { constFroz :: Bool + , constDecl :: Decl + , constVal :: exp + } deriving (Show, Eq, Ord) + +type Expr = Pos UnPosExpr + +data BinOp = Add + | Sub + | Mul + | Div + | Quot + | Rem + | Pow + | Or + | OrElse + | Xor + | And + | AndThen + | Implies + | RelOp ROp Typ + | SymbolOp Text + deriving (Show, Ord, Eq) + +data ROp = Lte + | Lt + | Eq + | TildeEq + | Neq + | TildeNeq + | Gt + | Gte + deriving (Show, Ord, Eq) + +data UnOp = Not + | Neg + | Old + deriving (Show, Ord, Eq) + +data UnPosExpr = + UnqualCall Text [Expr] + | QualCall Expr Text [Expr] + | Lookup Expr [Expr] + | PrecursorCall (Maybe Text) [Expr] + | BinOpExpr BinOp Expr Expr + | UnOpExpr UnOp Expr + | Address Expr + | Attached (Maybe Typ) Expr (Maybe Text) + | AcrossExpr Expr Text Quant Expr + | Agent Expr + | CreateExpr Typ Text [Expr] + | Tuple [Expr] + | InlineAgent [Decl] (Maybe Typ) [Stmt] [Expr] + | ManifestCast Typ Expr + | TypedVar Text Typ + | VarOrCall Text + | ResultVar + | OnceStr Text + | CurrentVar + | StaticCall Typ Text [Expr] + | LitArray [Expr] + | LitString Text + | LitChar Char + | LitInt Integer + | LitBool Bool + | LitVoid + | LitDouble Double + | LitType Typ deriving (Ord, Eq) + +data Quant = All | Some deriving (Eq, Ord, Show) + +commaSepShow es = intercalate "," (map show es) +argsShow args = "(" ++ commaSepShow args ++ ")" + +defaultCreate :: Text +defaultCreate = "default_create" + +instance Show UnPosExpr where + show (UnqualCall s args) = show s ++ argsShow args + show (QualCall t s args) = show t ++ "." ++ show s ++ argsShow args + show (Lookup t args) = show t ++ "[" ++ commaSepShow args ++ "]" + show (PrecursorCall t args) = "Precursor " ++ show t ++ argsShow args + show (BinOpExpr op e1 e2) + = "(" ++ show e1 ++ " " ++ show op ++ " " ++ show e2 ++ ")" + show (UnOpExpr op e) = "(" ++ show op ++ " " ++ show e ++ ")" + show (Attached s1 e s2) = "(attached " ++ show s1 ++ ", " + ++ show e ++ " as " ++ show s2 ++ ")" + show (CreateExpr t s args) + = "create {" ++ show t ++ "}." ++ show s + ++ "(" ++ intercalate "," (map show args) ++ ")" + show (AcrossExpr c as quant e) = + "across " ++ show c ++ " as " ++ show as ++ " " + ++ show quant ++ " " ++ show e + show (TypedVar var t) = "(" ++ show var ++ ": " ++ show t ++ ")" + show (ManifestCast t e) = "{" ++ show t ++ "} " ++ show e + show (StaticCall t i args) = "{" ++ show t ++ "}." + ++ show i ++ argsShow args + show (Address e) = "$" ++ show e + show (OnceStr s) = "once " ++ show s + show (VarOrCall s) = show s + show ResultVar = "Result" + show CurrentVar = "Current" + show (LitString s) = "\"" ++ show s ++ "\"" + show (LitChar c) = "'" ++ [c] ++ "'" + show (LitInt i) = show i + show (LitBool b) = show b + show (LitDouble d) = show d + show (LitType t) = "({" ++ show t ++ "})" + show (Tuple es) = show es + show (LitArray es) = "<<" ++ commaSepShow es ++ ">>" + show (Agent e) = "agent " ++ show e + show (InlineAgent ds r ss args) = + "agent " ++ show ds ++ ":" ++ show r ++ " " ++ show ss + ++ " " ++ show args + show LitVoid = "Void" + + + + +data Typ = ClassType ClassName [Typ] + | TupleType (Either [Typ] [Decl]) + | Sep (Maybe Proc) [Proc] Text + | Like Text + | VoidType + | NoType deriving (Eq, Ord, G.Generic) + +instance Hashable Typ + +data Decl = Decl + { declName :: Text, + declType :: Typ + } deriving (Ord, Eq, G.Generic) +instance Hashable Decl + +instance Show Decl where + show (Decl name typ) = show name ++ ":" ++ show typ + + +data Proc = Dot + | Proc {unProcGen :: Text} + deriving (Eq, Ord, G.Generic) +instance Hashable Proc + +instance Show Proc where + show Dot = "<.>" + show p = show $ unProcGen p + + +instance Show Typ where + show (Sep c ps t) = concat [ "separate <", show c, ">" + , show (map unProcGen ps)," ",show t + ] + show NoType = "notype" + show VoidType = "NONE" + show (Like e) = "like " ++ show e + show (ClassType s gs) = show s ++ show gs + show (TupleType typesDecls) = "TUPLE " ++ show typesDecls + +type ClassName = Text + +type Stmt = PosAbsStmt Expr +type UnPosStmt = AbsStmt Expr +type PosAbsStmt a = Pos (AbsStmt a) +data AbsStmt a = Assign a a + | AssignAttempt a a + | If a (PosAbsStmt a) [ElseIfPart a] (Maybe (PosAbsStmt a)) + | Malloc ClassName + | Create (Maybe Typ) a Text [a] + | Across a Text (PosAbsStmt a) + | Loop (PosAbsStmt a) [Clause a] a (PosAbsStmt a) (Maybe a) + | CallStmt a + | Retry + | Inspect a [([a], PosAbsStmt a)] (Maybe (PosAbsStmt a)) + | Check [Clause a] + | CheckBlock [Clause a] (PosAbsStmt a) + | Block [PosAbsStmt a] + | Debug Text (PosAbsStmt a) + | Print a + | PrintD a + | BuiltIn deriving (Ord, Eq) + +data ElseIfPart a = ElseIfPart a (PosAbsStmt a) deriving (Show, Ord, Eq) + +instance Show a => Show (AbsStmt a) where + show (Block ss) = intercalate ";\n" . map show $ ss + show (If b body elseifs elseMb) = concat + [ "if ", show b, "\n" + , "then ", show body, "\n" + , "elseifs: ", show elseifs, "\n" + , "else: ", show elseMb + ] + show (Inspect i cases def) = "inspect " ++ show i + ++ concat (map showCase cases) + ++ showDefault def + show (Across e as stmt) = "across " ++ show e ++ " " ++ show as ++ + "\nloop\n" ++ show stmt ++ "\nend" + show Retry = "retry" + show (Check cs) = "check " ++ show cs ++ " end" + show (CheckBlock e body) = "checkBlock " ++ show e ++ "\n" ++ show body + show (Create t trg fName args) = + concat ["create ", braced t, show trg, ".", show fName, show args] + show (CallStmt e) = show e + show (Assign i e) = show i ++ " := " ++ show e ++ "\n" + show (AssignAttempt i e) = show i ++ " ?= " ++ show e ++ "\n" + show (Print e) = "Printing: " ++ show e ++ "\n" + show (PrintD e) = "PrintingD: " ++ show e ++ "\n" + show (Loop fr _ un l var) = "from" ++ show fr ++ " until" ++ show un ++ + " loop " ++ show l ++ "variant" ++ show var ++ "end" + show (Malloc s) = "Malloc: " ++ show s + show (Debug str stmt) = "debug (" ++ show str ++ ")\n" + ++ show stmt ++ "end\n" + show BuiltIn = "built_in" + +braced t = case t of + Nothing -> "" + Just t' -> "{" ++ show t' ++ "}" + +showCase (l, s) = "when " ++ show l ++ " then\n" ++ show s +showDefault Nothing = "" +showDefault (Just s) = "else\n" ++ show s + +data ProcExpr = LessThan Proc Proc deriving (Show, Eq, Ord) + +data ProcDecl = SubTop Proc + | CreateLessThan Proc Proc + deriving (Show, Eq, Ord) + +data Clause a = Clause + { clauseName :: Maybe Text + , clauseExpr :: a + } deriving (Show, Ord, Eq) + + +data Note = Note { noteTag :: Text + , noteContent :: [UnPosExpr] + } deriving (Show, Eq, Ord) + + +instance Binary Text where + put = put . Text.encodeUtf8 + get = fmap Text.decodeUtf8 get + +instance (Eq k, Hashable k, Binary k, Binary v) => + Binary (HashMap k v) where + put = put . Map.toList + get = fmap Map.fromList get + +$( derive makeBinary ''Typ ) +$( derive makeBinary ''UnPosExpr ) +$( derive makeBinary ''BinOp ) +$( derive makeBinary ''Quant ) +$( derive makeBinary ''Decl ) +$( derive makeBinary ''UnOp ) +$( derive makeBinary ''ROp ) + +$( derive makeBinary ''AbsStmt ) +$( derive makeBinary ''ElseIfPart ) + +$( derive makeBinary ''ProcExpr ) + +$( derive makeBinary ''ExportList ) +$( derive makeBinary ''ExportClause ) +$( derive makeBinary ''RenameClause ) + +$( derive makeBinary ''Constant ) +$( derive makeBinary ''Attribute ) +$( derive makeBinary ''AbsRoutine ) +$( derive makeBinary ''EmptyBody ) + +$( derive makeBinary ''Contract ) + +$( derive makeBinary ''Proc ) +$( derive makeBinary ''ProcDecl ) +$( derive makeBinary ''Generic ) +$( derive makeBinary ''Clause ) +$( derive makeBinary ''FeatureClause ) +$( derive makeBinary ''ConvertClause ) +$( derive makeBinary ''CreateClause ) +$( derive makeBinary ''InheritClause ) +$( derive makeBinary ''Inheritance ) +$( derive makeBinary ''Note ) +$( derive makeBinary ''SomeFeature ) +$( derive makeBinary ''FeatureMap ) +$( derive makeBinary ''ExportedFeature ) +$( derive makeBinary ''AbsClas ) + + +$( derive makeNFData ''Typ ) +$( derive makeNFData ''UnPosExpr ) +$( derive makeNFData ''BinOp ) +$( derive makeNFData ''Quant ) +$( derive makeNFData ''Decl ) +$( derive makeNFData ''UnOp ) +$( derive makeNFData ''ROp ) + +$( derive makeNFData ''AbsStmt ) +$( derive makeNFData ''ElseIfPart ) + +$( derive makeNFData ''ProcExpr ) + +$( derive makeNFData ''ExportList ) +$( derive makeNFData ''ExportClause ) +$( derive makeNFData ''RenameClause ) + +$( derive makeNFData ''Constant ) +$( derive makeNFData ''Attribute ) +$( derive makeNFData ''AbsRoutine ) +$( derive makeNFData ''RoutineBody ) +$( derive makeNFData ''EmptyBody ) + +$( derive makeNFData ''Contract ) + +$( derive makeNFData ''Proc ) +$( derive makeNFData ''ProcDecl ) +$( derive makeNFData ''Generic ) +$( derive makeNFData ''Clause ) +$( derive makeNFData ''FeatureClause ) +$( derive makeNFData ''ConvertClause ) +$( derive makeNFData ''CreateClause ) +$( derive makeNFData ''InheritClause ) +$( derive makeNFData ''Inheritance ) +$( derive makeNFData ''Note ) +$( derive makeNFData ''SomeFeature ) +$( derive makeNFData ''ExportedFeature ) +$( derive makeNFData ''FeatureMap ) +$( derive makeNFData ''AbsClas ) + + +makeLenses ''ExportedFeature +makeLenses ''FeatureMap + +{-# INLINE fmRoutines #-} diff --git a/Language/Eiffel/Util.hs b/Language/Eiffel/Util.hs new file mode 100644 --- /dev/null +++ b/Language/Eiffel/Util.hs @@ -0,0 +1,752 @@ +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE FunctionalDependencies #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE ExistentialQuantification #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Rank2Types #-} +{-# LANGUAGE OverloadedStrings #-} + +module Language.Eiffel.Util where + +import Control.Applicative hiding (getConst) +import Control.Monad +import Control.Lens hiding (from, lens) + +import Data.Maybe +import qualified Data.HashMap.Strict as Map +import qualified Data.Text as Text +import Data.Text (Text) + +import Language.Eiffel.Syntax + +-- Class level utilities + +-- | A 'Feature' can provide its name, arguments, contract, etc. +class Feature a expr | a -> expr where + -- | The name of the feature. + featureName :: a -> Text + + -- | Argument declarations. + featureArgs :: a -> [Decl] + + -- | Result type. + featureResult :: a -> Typ + + -- | Precondition. + featurePre :: a -> [Clause expr] + + -- | Postconditions. + featurePost :: a -> [Clause expr] + + -- | Whether the feature is frozen (can't be redefined). + featureIsFrozen :: a -> Bool + + -- | Transform the feature given a renaming clause. + featureRename :: a -> RenameClause -> a + +-- | An existential type to aggregate +-- all features (routines, attributes, constants) together. +data FeatureEx expr = + -- | Wrap the 'Feature' in the existential type. + forall a. Feature a expr => FeatureEx a + +instance Feature (FeatureEx expr) expr where + featureName (FeatureEx f) = featureName f + featureArgs (FeatureEx f) = featureArgs f + featureResult (FeatureEx f) = featureResult f + featurePre (FeatureEx f) = featurePre f + featurePost (FeatureEx f) = featurePost f + featureIsFrozen (FeatureEx f) = featureIsFrozen f + featureRename (FeatureEx f) = FeatureEx . featureRename f + +-- | Wrap up SomeFeature + +wrapSomeFeature :: (forall f . Feature f expr => f -> b) + -> SomeFeature body expr + -> b +wrapSomeFeature f (SomeRoutine r) = f r +wrapSomeFeature f (SomeAttr a) = f a +wrapSomeFeature f (SomeConst c) = f c + +instance Feature (SomeFeature body expr) expr where + featureName = wrapSomeFeature featureName + featureArgs = wrapSomeFeature featureArgs + featureResult = wrapSomeFeature featureResult + featurePre = wrapSomeFeature featurePre + featurePost = wrapSomeFeature featurePost + featureIsFrozen = wrapSomeFeature featureIsFrozen + featureRename (SomeRoutine rout) r = SomeRoutine (featureRename rout r) + featureRename (SomeAttr attr) r = SomeAttr (featureRename attr r) + featureRename (SomeConst c) r = SomeConst (featureRename c r) + +instance Feature (AbsRoutine body expr) expr where + featureName = routineName + featureArgs = routineArgs + featureResult = routineResult + featurePre = contractClauses . routineReq + featurePost = contractClauses . routineEns + featureIsFrozen = routineFroz + featureRename rout r@(Rename orig new alias) + | routineName rout == orig = rout { routineName = new + , routineAlias = alias + , routineArgs = newArgs + } + | otherwise = rout {routineArgs = newArgs} + where newArgs = map (renameDecl r) (routineArgs rout) + +instance Feature (Attribute expr) expr where + featureName = declName . attrDecl + featureArgs = const [] + featureResult = declType . attrDecl + featurePre = contractClauses . attrReq + featurePost = contractClauses . attrEns + featureIsFrozen = attrFroz + featureRename attr r = + attr {attrDecl = renameDecl r (attrDecl attr)} + +instance Feature (Constant expr) expr where + featureName = declName . constDecl + featureArgs = const [] + featureResult = declType . constDecl + featurePre _ = [] + featurePost _ = [] + featureIsFrozen = constFroz + featureRename constant r = + constant {constDecl = renameDecl r (constDecl constant)} + +-- | A way to extract each type of feature from a class. +class Feature a expr => ClassFeature a body expr | a -> expr, a -> body where + -- | A list of all this class' features of the given type. + allFeatures :: AbsClas body expr -> [a] + + -- | Find this kind of feature in a class + findFeature :: AbsClas body expr -> Text -> Maybe a + +instance ClassFeature (Constant expr) body expr where + findFeature = findFeature' toConstMb + allFeatures = allConstants + +instance ClassFeature (AbsRoutine body expr) body expr where + findFeature = findFeature' toRoutineMb + allFeatures = allRoutines + +instance ClassFeature (Attribute expr) body expr where + findFeature = findFeature' toAttrMb + allFeatures = allAttributes + +instance ClassFeature (FeatureEx expr) body expr where + allFeatures clas = map FeatureEx (allAttributes clas) ++ + map FeatureEx (allRoutines clas) ++ + map FeatureEx (allConstants clas) + findFeature = findFeature' (Just . FeatureEx) + + +findFeature' :: (SomeFeature body expr -> Maybe a) + -> AbsClas body expr + -> Text + -> Maybe a +findFeature' from cls name = join $ from <$> findSomeFeature cls name + +-- | Convert a constant into an attribute. +constToAttr :: Constant exp -> Attribute Expr +constToAttr (Constant froz d _) = + Attribute froz d Nothing [] (Contract False []) (Contract False []) + +-- * Extracting data from a class. + +-- | Fetch attributes from all feature clauses. +allAttributes = allHelper fmAttrs + +-- | Fetch routines from all feature clauses. +allRoutines = allHelper fmRoutines + +-- | Fetch contants from all feature clauses. +allConstants = allHelper fmConsts + +-- Help for above 'all' functions +allHelper lens = + map (view exportFeat) . Map.elems . view lens . featureMap + +-- | Fetch creation routines from all feature clauses. +allCreates = concatMap createNames . creates + +-- | Fetch attribute declarations from all feature clauses. +allAttributeDecls = map attrDecl . allAttributes + +-- | Fetch constant declarations from all feature clauses. +allConstantDecls = map constDecl . allConstants + +-- | All inheritance clauses. +allInherited = concatMap inheritClauses . inherit + +-- | All inherited classes, as types. +allInheritedTypes = map inheritClass . allInherited + +-- | Determine if a name is in the creation clause of a class. +isCreateName n c = n `elem` allCreates c + +-- * 'SomeFeature' predicates, extractors. + +toRoutineMb (SomeRoutine r) = Just r +toRoutineMb _ = Nothing + +toAttrMb (SomeAttr r) = Just r +toAttrMb _ = Nothing + +toConstMb (SomeConst r) = Just r +toConstMb _ = Nothing + +-- isRoutine (SomeRoutine _) = True +-- isRoutine _ = False + +-- isAttr (SomeAttr _) = True +-- isAttr _ = False + +-- isConst (SomeConst _) = True +-- isConst _ = False + +-- getRoutine (SomeRoutine r) = r + +-- getAttr (SomeAttr a) = a + +-- getConst (SomeConst c) = c + +-- onlyRoutine f (SomeRoutine a) = SomeRoutine (f a) +-- onlyRoutine _f other = other + +-- onlyAttr f (SomeAttr a) = SomeAttr (f a) +-- onlyAttr _f other = other + +-- onlyConst f (SomeConst a) = SomeConst (f a) +-- onlyConst _f other = other + +-- onlyRoutineM f (SomeRoutine a) = SomeRoutine <$> f a +-- onlyRoutineM f other = pure other + +-- onlyAttrM :: Applicative m +-- => (Attribute exp -> m (Attribute exp)) +-- -> SomeFeature body exp +-- -> m (SomeFeature body exp) +-- onlyAttrM f (SomeAttr a) = SomeAttr <$> f a +-- onlyAttrM f other = pure other + +-- onlyConstM f (SomeConst a) = SomeConst (f a) +-- onlyConstM f other = other + + + +-- * Class modification + +-- ** Setting members of a class. + +-- | Set the feature clause of a class. +updFeatureMap :: AbsClas body exp -> FeatureMap body exp -> AbsClas body exp +updFeatureMap c featMap = c {featureMap = featMap} + +-- | Update a routine body. +updFeatBody :: RoutineBody a -> PosAbsStmt b -> RoutineBody b +updFeatBody impl body = impl {routineBody = body} + +-- ** Mapping features of a class +-- | These functions will update a class or feature clause with a transformation +-- function. + +-- | Map a transformation function over the routines in a class, replacing the +-- old routines with the transformed versions within a feature clause. +-- mapRoutines f = Map.map (over exportFeat (onlyRoutine f)) + +-- | Monadic version of 'mapRoutines'. +mapRoutinesM :: (Applicative m, Monad m) => + (AbsRoutine body exp -> m (AbsRoutine body exp)) -> + FeatureMap body exp -> + m (FeatureMap body exp) +mapRoutinesM f = mapMOf (fmRoutines.traverse.exportFeat) f + +-- | Map a transformation function over the attributes in a class, +-- replacing the old attributes with the transformed versions within a feature clause. +mapAttributes :: (Attribute exp -> Attribute exp) + -> FeatureMap body exp + -> FeatureMap body exp +mapAttributes f = over (fmAttrs.traverse.exportFeat) f + +-- | Monadic version of 'mapAttributes'. +mapAttributesM :: (Monad m, Applicative m) => + (Attribute exp -> m (Attribute exp)) -> + FeatureMap body exp -> + m (FeatureMap body exp) +mapAttributesM f = mapMOf (fmAttrs.traverse.exportFeat) f +-- | Map a transformation function over the constants in a class, replacing the +-- old constants with the transformed versions within a feature clause. +-- mapConstants f = Map.map (over exportFeat (onlyConst f)) + +-- | Map a transformation function over the contracts in a class, replacing the +-- old contracts with the transformed versions within a feature clause. +mapContract clauseF cs = + cs { contractClauses = map clauseF (contractClauses cs)} + +-- | Map a transformation function over all expressions in a class. +-- A transformation for features, constants, and attributes must be given +-- as if the type of expressions changes (ie, with a typecheck) then +-- all expressions types must change together. +mapExprs :: (AbsRoutine body exp -> AbsRoutine body' exp') + -> (Constant exp -> Constant exp') + -> (Clause exp -> Clause exp') + -> FeatureMap body exp + -> FeatureMap body' exp' +mapExprs routF constF clauseF fm = + FeatureMap (mapUpd routF fmRoutines) + (mapUpd updAttr fmAttrs) + (mapUpd constF fmConsts) + where + updAttr a = a { attrEns = mapContract clauseF (attrEns a) + , attrReq = mapContract clauseF (attrReq a) + } + + mapUpd f lens = Map.map (over exportFeat f) (view lens fm) + + +-- | Map a transformation function over the attributes in a class, replacing the +-- old attributes with the transformed versions within a class. +classMapAttributes f c = + c {featureMap = mapAttributes f (featureMap c)} + +-- | Monadic version of 'classMapAttributes'. +classMapAttributesM :: (Applicative m, Monad m) => + (Attribute exp -> m (Attribute exp)) -> + AbsClas body exp -> + m (AbsClas body exp) +classMapAttributesM f c = do + fm <- mapAttributesM f (featureMap c) + return (c {featureMap = fm}) + +-- | Map a transformation function over the routines in a class, replacing the +-- old routines with the transformed versions within a class. +classMapRoutines :: (AbsRoutine body exp -> AbsRoutine body exp) + -> AbsClas body exp -> AbsClas body exp +classMapRoutines f c = + c {featureMap = over (fmRoutines.traverse.exportFeat) f (featureMap c)} + +-- | Monadic version of 'classMapRoutines'. +classMapRoutinesM :: (Applicative m, Monad m) => + (AbsRoutine body exp -> m (AbsRoutine body exp)) -> + AbsClas body exp -> + m (AbsClas body exp) +classMapRoutinesM f c = do + fm <- mapRoutinesM f (featureMap c) + return (c {featureMap = fm}) + +-- | Map a transformation function over the constants in a class, replacing the +-- old constants with the transformed versions within a class. +classMapConstants f c = + c {featureMap = over (fmConsts.traverse.exportFeat) f (featureMap c)} + +-- | Map a transformation function over all expressions in a class. +-- A transformation for features, constants, and attributes must be given +-- as if the type of expressions changes (ie, with a typecheck) then +-- all expressions types must change together. This is performed on every +-- feature clause in a class. +classMapExprs :: (AbsRoutine body exp -> AbsRoutine body' exp') + -> (Clause exp -> Clause exp') + -> (Constant exp -> Constant exp') + -> AbsClas body exp -> AbsClas body' exp' +classMapExprs featrF clauseF constF c = + c { featureMap = mapExprs featrF constF clauseF (featureMap c) + , invnts = map clauseF (invnts c) + } + +-- * Interface construction + +-- | Strip the body from a routine. +makeRoutineIs :: SomeFeature body Expr -> SomeFeature EmptyBody Expr +makeRoutineIs (SomeRoutine r) = SomeRoutine (makeRoutineI r) +makeRoutineIs (SomeAttr a) = SomeAttr a +makeRoutineIs (SomeConst c) = SomeConst c + +-- | Strip the contracts from an attribute. +makeAttributeI :: Attribute exp -> Attribute Expr +makeAttributeI (Attribute froz decl assgn notes _ _) = + Attribute froz decl assgn notes (Contract False []) (Contract False []) + +-- | Strip the bodies from all features. +clasInterface :: AbsClas body Expr -> ClasInterface +clasInterface c = + c { featureMap = over (fmRoutines.traverse.exportFeat) + (makeRoutineI) + (featureMap c) + } + +-- | Strip the bodies and rescue clause from a routine. +makeRoutineI :: AbsRoutine body Expr -> RoutineI +makeRoutineI f = f { routineImpl = EmptyBody + , routineRescue = Nothing} + +-- * Map construction + +-- | Turn a list of classes into a map indexed by the class names. +clasMap :: [AbsClas body exp] -> Map ClassName (AbsClas body exp) +clasMap = Map.fromList . map (\ c -> (className c, c)) + +-- | Extract a map of attribute names to types given a class. +attrMap :: AbsClas body exp -> Map Text Typ +attrMap = declsToMap . map attrDecl . allAttributes + +-- * Search + +-- | Find a routine in a class. +findRoutine :: Clas -> Text -> Maybe Routine +findRoutine = findFeature + +-- | Find an operator (symbol sequence) in a class. +findOperator :: AbsClas body Expr -> Text -> Int -> + Maybe (AbsRoutine body Expr) +findOperator c opName numArgs = + let fs = allRoutines c + ffs = filter (\ rout -> routineAlias rout == Just opName && + length (routineArgs rout) == numArgs) fs + in listToMaybe ffs + +-- -- | Find a 'ClassFeature'. +-- findFeature :: ClassFeature a body expr => +-- AbsClas body expr -> Text -> Maybe a +-- findFeature clasInt name = +-- let fs = filter (\f -> Text.map toLower (featureName f) == Text.map toLower name) +-- (allFeatures clasInt) +-- in listToMaybe fs + +-- | Find the sum-type for all features. +findSomeFeature :: AbsClas body expr -> Text -> Maybe (SomeFeature body expr) +findSomeFeature cls name = + lkup fmRoutines SomeRoutine <|> + lkup fmAttrs SomeAttr <|> + lkup fmConsts SomeConst + where + lkup lens cast = cast <$> + view exportFeat <$> + Map.lookup nameLow (view lens featMap) + featMap = featureMap cls + nameLow = Text.toLower name + +-- | Find an existential 'FeatureEx'. +findFeatureEx :: AbsClas body expr -> Text -> Maybe (FeatureEx expr) +findFeatureEx = findFeature + +-- | Find a routine by name. +findRoutineInt :: ClasInterface -> Text -> Maybe RoutineI +findRoutineInt = findFeature + +-- | Find an attribute in a class by name. +findAttrInt :: AbsClas body expr -> Text -> Maybe (Attribute expr) +findAttrInt = findFeature + +-- | Find a constant by name in a class. +findConstantInt :: AbsClas body Expr -> Text -> Maybe (Constant Expr) +findConstantInt = findFeature + +-- | Given a class and a routine, given a unique name. +fullName :: AbsClas body exp -> RoutineI -> Text +fullName c f = fullNameStr (className c) (routineName f) + +-- | Given to string construct a unique combination. +fullNameStr :: Text -> Text -> Text +fullNameStr cName fName = Text.concat ["__", cName, "_", fName] + +-- | Given a class, create a list of generic classes for the formal generic +-- parameters of the class. +genericStubs :: AbsClas body exp -> [AbsClas body' exp'] +genericStubs = map makeGenericStub . generics + +-- | Given a generic, construct a class for the generic. +makeGenericStub :: Generic -> AbsClas body exp +makeGenericStub (Generic g constrs _) = + AbsClas { deferredClass = False + , frozenClass = False + , expandedClass = False + , classNote = [] + , className = g + , currProc = Dot + , procGeneric = [] + , obsoleteClass = False + , procExpr = [] + , generics = [] + , inherit = [Inheritance False $ map simpleInherit constrs] + , creates = [] + , converts = [] + , featureMap = FeatureMap Map.empty Map.empty Map.empty + , invnts = [] + } + where + simpleInherit t = InheritClause t [] [] [] [] [] + +-- * Inheritance utilities + +-- | Rename a declaration. +renameDecl :: RenameClause -> Decl -> Decl +renameDecl r@(Rename orig new _) (Decl n t) + | n == orig = Decl new t' + | otherwise = Decl n t' + where + t' = renameType r t + +-- | Rename a type, in the case of a like-type. +renameType r (ClassType n ts) = ClassType n (map (renameType r) ts) +renameType (Rename orig new _) (Like i) + | i == orig = Like new + | otherwise = Like i +renameType r t = error $ "renameType: rename " ++ show r ++ + " in type: " ++ show t + +-- | Rename everything in a class. +renameAll :: [RenameClause] -> AbsClas body exp -> AbsClas body exp +renameAll renames cls = renamed + -- | Map.size (featureMap cls) == Map.size (featureMap renamed) = renamed + -- | otherwise = error $ "renameAll: changed number of entries: " ++ + -- show (Map.keys $ featureMap cls, Map.keys $ featureMap renamed, renames, className cls) + where + renamed = foldr renameClass cls renames + + renameKey (Rename old new _aliasMb) k + | k == Text.toLower old = new + | otherwise = k + renameKeys r c = c { featureMap = fmMapKeys (renameKey r) (featureMap c)} + renameClass r = renameKeys r . + classMapConstants (flip featureRename r) . + classMapAttributes (flip featureRename r) . + classMapRoutines (flip featureRename r) + +-- | Undefine a single feature in a class. +undefineName :: Text -> AbsClas body exp -> AbsClas body exp +undefineName name cls = + cls { featureMap = fmKeyFilter (/= name) (featureMap cls)} + +-- | Undefine every specified name for a class. +undefineAll :: InheritClause -> AbsClas body exp -> AbsClas body exp +undefineAll inh cls = foldr undefineName cls (undefine inh) + +-- | Specifies whether a class can be merged with another. +mergeableClass :: AbsClas body exp -> Bool +mergeableClass _clas = True -- null (generics clas) -- && null (inherit clas) + +-- | Merge two classes, combining invariants and feature clauses. +mergeClass :: AbsClas body exp -> AbsClas body exp -> AbsClas body exp +mergeClass class1 class2 + | mergeableClass class1 && mergeableClass class2 = + class1 { invnts = invnts class1 ++ invnts class2 + , featureMap = featureMap class1 `fmUnion` featureMap class2 + } + | otherwise = error $ "mergeClasses: classes not mergeable " ++ + show (className class1, className class2) + +-- | Merge a list of classes. +mergeClasses :: [AbsClas body exp] -> AbsClas body exp +mergeClasses = foldr1 mergeClass + + +-- * Feature Map functions +fmMapKeys :: (Text -> Text) -> FeatureMap body exp -> FeatureMap body exp +fmMapKeys f = fmKeyMap fmRoutines . fmKeyMap fmAttrs . fmKeyMap fmConsts + where + fmKeyMap setter = over setter mapKeys + + mapKeys :: Map Text v -> Map Text v + mapKeys = Map.fromList . map (\(k,v) -> (f k, v)) . Map.toList + +fmKeyFilter :: (Text -> Bool) + -> FeatureMap body exp + -> FeatureMap body exp +fmKeyFilter p = fmFilt fmRoutines . fmFilt fmAttrs . fmFilt fmConsts + where + fmFilt setter = over setter filt + filt = Map.filterWithKey (\ k _v -> p k) + +fmUnion + :: FeatureMap body exp + -> FeatureMap body exp + -> FeatureMap body exp +fmUnion fm1 fm2 = + FeatureMap + (Map.union (view fmRoutines fm1) (view fmRoutines fm2)) + (Map.union (view fmAttrs fm1) (view fmAttrs fm2)) + (Map.union (view fmConsts fm1) (view fmConsts fm2)) + +fmEmpty = FeatureMap Map.empty Map.empty Map.empty + +fmUnions = foldr fmUnion fmEmpty + +-- * Routine level utilities + +-- | Construct a map from a routine's arguments. +argMap :: RoutineWithBody a -> Map Text Typ +argMap = declsToMap . routineArgs + +-- | Construct a map from a routine's declarations. +localMap :: RoutineWithBody a -> Map Text Typ +localMap = declsToMap . routineDecls + +-- | Give the declarations of a routine's locals. +routineDecls :: AbsRoutine (RoutineBody exp1) exp -> [Decl] +routineDecls r = + case routineImpl r of + RoutineDefer -> [] + RoutineExternal _ _ -> [] + body -> routineLocal body + +-- Operator utilities + +-- | Operator aliases for user-level operators, ie, not including +-- =, /=, ~, and /~ +opAlias :: BinOp -> Text +opAlias Add = "+" +opAlias Sub = "-" +opAlias Mul = "*" +opAlias Div = "/" +opAlias Quot = "//" +opAlias Rem = "\\" +opAlias Pow = "^" +opAlias And = "and" +opAlias AndThen = "and then" +opAlias Or = "or" +opAlias OrElse = "or else" +opAlias Xor = "xor" +opAlias Implies = "implies" +opAlias (SymbolOp o) = o +opAlias (RelOp o _) = rel o + where + rel Lte = "<=" + rel Lt = "<" + rel Gt = ">" + rel Gte = ">=" + rel relOp = error $ "opAlias: non user-level operator " ++ show relOp + +-- | Test if the binary operator is an equality operator. +equalityOp :: BinOp -> Bool +equalityOp (RelOp Eq _) = True +equalityOp (RelOp Neq _) = True +equalityOp (RelOp TildeEq _) = True +equalityOp (RelOp TildeNeq _) = True +equalityOp _ = False + + +-- | Unary operator aliases for everything except `old'. +unOpAlias Not = "not" +unOpAlias Neg = "-" +unOpAlias Old = "unOpAlias: `old' is not a user-operator." + + +-- * Type utilities + +-- | Convert a class into its type. +classToType :: AbsClas body exp -> Typ +classToType clas = ClassType (className clas) (map genType (generics clas)) + where genType g = ClassType (genericName g) [] + +-- | Whether a type is basic (where basic meaning its an integer, natural, real or boolean). +isBasic :: Typ -> Bool +isBasic t = any ($ t) [isBooleanType, isIntegerType, isNaturalType, isRealType, isCharType] + +-- | A list of the number of integer bits (8, 16, ...) +intBits :: [Integer] +intBits = [8, 16, 32, 64] + + +-- | The bounds on the range of values a integer or natural type can take. +typeBounds :: Typ -> (Integer, Integer) +typeBounds (ClassType n []) = fromJust $ lookup n wholeMap + where + intMap = zip integerTypeNames + (map (\bits -> let half = bits `quot` 2 + in (- 2^half, 2^half - 1)) intBits) + natMap = zip naturalTypeNames + (map (\bits -> (0, 2^bits - 1)) intBits) + wholeMap = intMap ++ natMap +typeBounds t = error $ "typeBounds: won't work on " ++ show t + +-- | Boolean type test. +isBooleanType :: Typ -> Bool +isBooleanType = (== "BOOLEAN") . classNameType + +-- | Integer type test. +isIntegerType :: Typ -> Bool +isIntegerType = isInTypeNames integerTypeNames + +-- | Natural number type test. +isNaturalType :: Typ -> Bool +isNaturalType = isInTypeNames naturalTypeNames + +-- | Real number type test. +isRealType :: Typ -> Bool +isRealType = isInTypeNames realTypeNames + +-- | Character type test. +isCharType :: Typ -> Bool +isCharType = isInTypeNames charTypeNames + +isInTypeNames names (ClassType name _) = name `elem` names +isInTypeNames _ _ = False + +-- | List of integer type names (ie, INTEGER_32). +integerTypeNames :: [Text] +integerTypeNames = map ((Text.append "INTEGER_") . Text.pack . show) intBits + +-- | List of integer type names (ie, NATURAL_32). +naturalTypeNames :: [Text] +naturalTypeNames = map ((Text.append "NATURAL_") . Text.pack . show) intBits + +-- | List of integer type names (ie, REAL_64). +realTypeNames :: [Text] +realTypeNames = ["REAL_32", "REAL_64"] + +-- | List of integer type names (ie, CHARACTER_8). +charTypeNames :: [Text] +charTypeNames = ["CHARACTER_8", "CHARACTER_32"] + +-- | Given a type give the name of the class as a string. +classNameType :: Typ -> Text +classNameType (ClassType cn _) = cn +classNameType (Sep _ _ cn) = cn +classNameType t = error $ "Non-class type " ++ show t + +-- | The default integer type. +intType :: Typ +intType = namedType "INTEGER_32" + +-- | The default boolean type. +boolType :: Typ +boolType = namedType "BOOLEAN" + +-- | The default real number type. +realType :: Typ +realType = namedType "REAL_64" + +-- | The default character type. +charType :: Typ +charType = namedType "CHARACTER_8" + +-- | The default string type. +stringType :: Typ +stringType = namedType "STRING_8" + +-- | The top type, ANY. +anyType :: Typ +anyType = namedType "ANY" + +-- | Construct a simple type from a classname. +namedType :: ClassName -> Typ +namedType name = ClassType name [] + +-- * Declaration + +-- | Insert a declaration into a string-type map. +insertDecl :: Decl -> Map Text Typ -> Map Text Typ +insertDecl (Decl s t) = Map.insert s t + +-- | Turn a list of declarations into a string-type map. +declsToMap :: [Decl] -> Map Text Typ +declsToMap = foldr insertDecl Map.empty + +-- * SCOOP utilities + +-- | Given a processor declaration, extract the processor. +newVar :: ProcDecl -> Proc +newVar (SubTop p) = p +newVar (CreateLessThan p _) = p diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/dist/build/Language/Eiffel/Parser/Lex.hs b/dist/build/Language/Eiffel/Parser/Lex.hs new file mode 100644 --- /dev/null +++ b/dist/build/Language/Eiffel/Parser/Lex.hs @@ -0,0 +1,937 @@ +{-# LANGUAGE CPP,MagicHash,BangPatterns #-} +{-# LINE 1 "Language/Eiffel/Parser/Lex.x" #-} + +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE ScopedTypeVariables #-} +module Language.Eiffel.Parser.Lex + ( Parser + , Token (..) + , SpanToken (..) + , Assoc (..) + , keyword + , identifier + , squares + , comma + , identifierNamed + , colon + , parens + , semicolon + , period + , symbol + , braces + + , arrayStart + , arrayEnd + + , attachTokenPos + + -- , freeOperator + , binOpToken + , opInfo + , opNamed + , opSymbol + + , tokenizer + , tokenizeFile + + , charTok + , stringTok + , anyStringTok + , integerTok + , floatTok + , boolTok + ) + where + +import Control.DeepSeq + +import Data.Char +import qualified Data.Map as Map +import qualified Data.ByteString.Lazy.Char8 as BL +import qualified Data.ByteString.Char8 as BS +import qualified Data.Text as Text +import qualified Data.Text.Encoding as Text +import Data.Text (Text) + +import Language.Eiffel.Position +import Language.Eiffel.Syntax + +import Text.Parsec +import Text.Parsec.Pos + +#if __GLASGOW_HASKELL__ >= 603 +#include "ghcconfig.h" +#elif defined(__GLASGOW_HASKELL__) +#include "config.h" +#endif +#if __GLASGOW_HASKELL__ >= 503 +import Data.Array +import Data.Char (ord) +import Data.Array.Base (unsafeAt) +#else +import Array +import Char (ord) +#endif +#if __GLASGOW_HASKELL__ >= 503 +import GHC.Exts +#else +import GlaExts +#endif +{-# LINE 1 "templates/wrappers.hs" #-} +{-# LINE 1 "templates/wrappers.hs" #-} +{-# LINE 1 "" #-} +{-# LINE 1 "" #-} +{-# LINE 1 "templates/wrappers.hs" #-} +-- ----------------------------------------------------------------------------- +-- Alex wrapper code. +-- +-- This code is in the PUBLIC DOMAIN; you may copy it freely and use +-- it for any purpose whatsoever. + +import Data.Word (Word8) + + +import qualified Data.Char +import qualified Data.ByteString.Lazy as ByteString +import qualified Data.ByteString.Internal as ByteString (w2c) + +{-# LINE 47 "templates/wrappers.hs" #-} + +type Byte = Word8 + +-- ----------------------------------------------------------------------------- +-- The input type + +{-# LINE 71 "templates/wrappers.hs" #-} + + +type AlexInput = (AlexPosn, -- current position, + Char, -- previous char + ByteString.ByteString) -- current input string + +alexInputPrevChar :: AlexInput -> Char +alexInputPrevChar (p,c,s) = c + +alexGetByte :: AlexInput -> Maybe (Byte,AlexInput) +alexGetByte (p,_,cs) | ByteString.null cs = Nothing + | otherwise = let b = ByteString.head cs + cs' = ByteString.tail cs + c = ByteString.w2c b + p' = alexMove p c + in p' `seq` cs' `seq` Just (b, (p', c, cs')) + + +{-# LINE 102 "templates/wrappers.hs" #-} + +{-# LINE 117 "templates/wrappers.hs" #-} + +-- ----------------------------------------------------------------------------- +-- Token positions + +-- `Posn' records the location of a token in the input text. It has three +-- fields: the address (number of chacaters preceding the token), line number +-- and column of a token within the file. `start_pos' gives the position of the +-- start of the file and `eof_pos' a standard encoding for the end of file. +-- `move_pos' calculates the new position after traversing a given character, +-- assuming the usual eight character tab stops. + + +data AlexPosn = AlexPn !Int !Int !Int + deriving (Eq,Show) + +alexStartPos :: AlexPosn +alexStartPos = AlexPn 0 1 1 + +alexMove :: AlexPosn -> Char -> AlexPosn +alexMove (AlexPn a l c) '\t' = AlexPn (a+1) l (((c+7) `div` 8)*8+1) +alexMove (AlexPn a l c) '\n' = AlexPn (a+1) (l+1) 1 +alexMove (AlexPn a l c) _ = AlexPn (a+1) l (c+1) + + +-- ----------------------------------------------------------------------------- +-- Default monad + +{-# LINE 230 "templates/wrappers.hs" #-} + + +-- ----------------------------------------------------------------------------- +-- Monad (with ByteString input) + + +data AlexState = AlexState { + alex_pos :: !AlexPosn, -- position at current input location + alex_inp :: ByteString.ByteString, -- the current input + alex_chr :: !Char, -- the character before the input + alex_scd :: !Int -- the current startcode + + + + } + +-- Compile with -funbox-strict-fields for best results! + +runAlex :: ByteString.ByteString -> Alex a -> Either String a +runAlex input (Alex f) + = case f (AlexState {alex_pos = alexStartPos, + alex_inp = input, + alex_chr = '\n', + + + + alex_scd = 0}) of Left msg -> Left msg + Right ( _, a ) -> Right a + +newtype Alex a = Alex { unAlex :: AlexState -> Either String (AlexState, a) } + +instance Monad Alex where + m >>= k = Alex $ \s -> case unAlex m s of + Left msg -> Left msg + Right (s',a) -> unAlex (k a) s' + return a = Alex $ \s -> Right (s,a) + +alexGetInput :: Alex AlexInput +alexGetInput + = Alex $ \s@AlexState{alex_pos=pos,alex_chr=c,alex_inp=inp} -> + Right (s, (pos,c,inp)) + +alexSetInput :: AlexInput -> Alex () +alexSetInput (pos,c,inp) + = Alex $ \s -> case s{alex_pos=pos,alex_chr=c,alex_inp=inp} of + s@(AlexState{}) -> Right (s, ()) + +alexError :: String -> Alex a +alexError message = Alex $ \s -> Left message + +alexGetStartCode :: Alex Int +alexGetStartCode = Alex $ \s@AlexState{alex_scd=sc} -> Right (s, sc) + +alexSetStartCode :: Int -> Alex () +alexSetStartCode sc = Alex $ \s -> Right (s{alex_scd=sc}, ()) + +alexMonadScan = do + inp <- alexGetInput + sc <- alexGetStartCode + case alexScan inp sc of + AlexEOF -> alexEOF + AlexError inp' -> alexError "lexical error" + AlexSkip inp' len -> do + alexSetInput inp' + alexMonadScan + AlexToken inp' len action -> do + alexSetInput inp' + action (ignorePendingBytes inp) len + +-- ----------------------------------------------------------------------------- +-- Useful token actions + +type AlexAction result = AlexInput -> Int -> Alex result + +-- just ignore this token and scan another one +-- skip :: AlexAction result +skip input len = alexMonadScan + +-- ignore this token, but set the start code to a new value +-- begin :: Int -> AlexAction result +begin code input len = do alexSetStartCode code; alexMonadScan + +-- perform an action for this token, and set the start code to a new value +andBegin :: AlexAction result -> Int -> AlexAction result +(action `andBegin` code) input len = do alexSetStartCode code; action input len + +token :: (AlexInput -> Int -> token) -> AlexAction token +token t input len = return (t input len) + + + +-- ----------------------------------------------------------------------------- +-- Basic wrapper + +{-# LINE 345 "templates/wrappers.hs" #-} + + +-- ----------------------------------------------------------------------------- +-- Basic wrapper, ByteString version + +{-# LINE 363 "templates/wrappers.hs" #-} + +{-# LINE 376 "templates/wrappers.hs" #-} + + +-- ----------------------------------------------------------------------------- +-- Posn wrapper + +-- Adds text positions to the basic model. + +{-# LINE 393 "templates/wrappers.hs" #-} + + +-- ----------------------------------------------------------------------------- +-- Posn wrapper, ByteString version + +{-# LINE 408 "templates/wrappers.hs" #-} + + +-- ----------------------------------------------------------------------------- +-- GScan wrapper + +-- For compatibility with previous versions of Alex, and because we can. + +alex_base :: AlexAddr +alex_base = AlexA# "\x01\x00\x00\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\xd6\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x4b\x01\x00\x00\x66\x00\x00\x00\x20\x00\x00\x00\x13\x00\x00\x00\x22\x00\x00\x00\x15\x00\x00\x00\xcb\x01\x00\x00\x4b\x02\x00\x00\xcb\x02\x00\x00\x4b\x03\x00\x00\xcb\x03\x00\x00\x4b\x04\x00\x00\x2b\x05\x00\x00\x2c\x05\x00\x00\x12\x05\x00\x00\x00\x00\x00\x00\x83\x05\x00\x00\x63\x06\x00\x00\x64\x06\x00\x00\x00\x00\x00\x00\x4a\x06\x00\x00\x00\x00\x00\x00\xbb\x06\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x1d\x00\x00\x00\x38\x00\x00\x00\x35\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x8e\x04\x00\x00\x00\x00\x00\x00\x2c\x07\x00\x00\x00\x00\x00\x00\xc6\x05\x00\x00\x2c\x08\x00\x00\xec\x07\x00\x00\x00\x00\x00\x00\xec\x08\x00\x00\xac\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x08\x00\x00\xed\x09\x00\x00\xad\x09\x00\x00\x00\x00\x00\x00\xa4\x0a\x00\x00\x90\x0b\x00\x00\x05\x0c\x00\x00\x73\x00\x00\x00\xf4\x0a\x00\x00\x82\x00\x00\x00\x96\x06\x00\x00\x7e\x0a\x00\x00\x1c\x00\x00\x00\x40\x00\x00\x00\x05\x0d\x00\x00\xc5\x0c\x00\x00\x00\x00\x00\x00\x25\x0b\x00\x00\xbb\x0d\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\x9f\x0d\x00\x00\x00\x00\x00\x00\x9b\x0e\x00\x00\xef\x0e\x00\x00\x00\x00\x00\x00\x4a\x0f\x00\x00\x9e\x0f\x00\x00\xf2\x0f\x00\x00\x46\x10\x00\x00\x00\x00\x00\x00\x9a\x10\x00\x00\x00\x00\x00\x00\xe3\x0b\x00\x00\x88\x0a\x00\x00\xe5\x10\x00\x00\xed\x0b\x00\x00\xfe\x10\x00\x00\x0a\x11\x00\x00\x2a\x11\x00\x00\x4d\x11\x00\x00\x00\x00\x00\x00\x6b\x11\x00\x00\xbf\x11\x00\x00\x13\x12\x00\x00\x67\x12\x00\x00\xbb\x12\x00\x00\x0f\x13\x00\x00\x63\x13\x00\x00\xb7\x13\x00\x00\x0b\x14\x00\x00\x5f\x14\x00\x00\xba\x14\x00\x00\x0e\x15\x00\x00\x62\x15\x00\x00\xb6\x15\x00\x00\x0a\x16\x00\x00\x5e\x16\x00\x00\xb2\x16\x00\x00\x06\x17\x00\x00\x5a\x17\x00\x00\xae\x17\x00\x00\x02\x18\x00\x00\x56\x18\x00\x00\xaa\x18\x00\x00\xfe\x18\x00\x00\x52\x19\x00\x00\xad\x19\x00\x00\x01\x1a\x00\x00\x55\x1a\x00\x00\xa9\x1a\x00\x00\xfd\x1a\x00\x00\x51\x1b\x00\x00\xa5\x1b\x00\x00\xf9\x1b\x00\x00\x4d\x1c\x00\x00\xa1\x1c\x00\x00\xf5\x1c\x00\x00\x49\x1d\x00\x00\x00\x00\x00\x00\xa4\x1d\x00\x00\x90\x1e\x00\x00\x00\x00\x00\x00\x7c\x1f\x00\x00\x68\x20\x00\x00\x00\x00\x00\x00"# + +alex_table :: AlexAddr +alex_table = AlexA# "\x00\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x41\x00\x85\x00\x84\x00\x58\x00\x58\x00\x85\x00\x58\x00\x80\x00\x59\x00\x59\x00\x58\x00\x58\x00\x7f\x00\x57\x00\x58\x00\x58\x00\x56\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x7f\x00\x7f\x00\x58\x00\x58\x00\x58\x00\x7f\x00\x58\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x59\x00\x58\x00\x59\x00\x58\x00\x85\x00\x7f\x00\x79\x00\x6e\x00\x6e\x00\x6e\x00\x6f\x00\x6e\x00\x6e\x00\x6e\x00\x67\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x7c\x00\x6e\x00\x6e\x00\x6d\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x5f\x00\x6e\x00\x6e\x00\x59\x00\x58\x00\x59\x00\x58\x00\x85\x00\x44\x00\x44\x00\x49\x00\x50\x00\x3d\x00\x04\x00\x3c\x00\x05\x00\x0b\x00\x4e\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x01\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x07\x00\x0a\x00\x09\x00\x08\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x3b\x00\x46\x00\x3b\x00\x44\x00\x00\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x32\x00\x0c\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x28\x00\x10\x00\x1b\x00\x1b\x00\x1b\x00\x1c\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x43\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x02\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x2c\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2d\x00\x0e\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x24\x00\x11\x00\x19\x00\x19\x00\x19\x00\x1a\x00\x3e\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x31\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x06\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2c\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x29\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x0c\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x0e\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x12\x00\x13\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x21\x00\x1f\x00\x0f\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x22\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x00\x00\x00\x00\x34\x00\x34\x00\x82\x00\x34\x00\x34\x00\x36\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x00\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2a\x00\x0f\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1e\x00\x14\x00\x15\x00\x15\x00\x15\x00\x16\x00\x34\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x34\x00\x82\x00\x34\x00\x34\x00\x36\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x00\x00\x00\x00\x35\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x83\x00\x39\x00\x00\x00\x36\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2a\x00\x0f\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1e\x00\x14\x00\x15\x00\x15\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x29\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2a\x00\x0f\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1e\x00\x14\x00\x15\x00\x15\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3e\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x3f\x00\x06\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x30\x00\x0d\x00\x25\x00\x25\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x78\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x77\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x3a\x00\x00\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x3a\x00\x00\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x00\x00\x58\x00\x58\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x58\x00\x58\x00\x00\x00\x42\x00\x58\x00\x58\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x58\x00\x58\x00\x37\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x58\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x58\x00\x58\x00\x00\x00\x58\x00\x58\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x58\x00\x58\x00\x58\x00\x58\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x58\x00\x00\x00\x58\x00\x58\x00\x00\x00\x58\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x58\x00\x6e\x00\x58\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x48\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x4c\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x4f\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x7e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x5a\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x7b\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x5b\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x7a\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x5c\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x60\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x75\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x73\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x64\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x72\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x71\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x70\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x68\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x69\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6b\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6c\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6a\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x66\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x65\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x74\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x76\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x63\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x62\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x61\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x5e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x5d\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x7d\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x4d\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x4b\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x4a\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x47\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x45\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x03\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2d\x00\x0e\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x24\x00\x11\x00\x19\x00\x19\x00\x19\x00\x1a\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x34\x00\x82\x00\x34\x00\x34\x00\x36\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2a\x00\x0f\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1e\x00\x14\x00\x15\x00\x15\x00\x15\x00\x16\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x34\x00\x82\x00\x34\x00\x34\x00\x36\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2a\x00\x0f\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1e\x00\x14\x00\x15\x00\x15\x00\x15\x00\x16\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x34\x00\x82\x00\x34\x00\x34\x00\x36\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x81\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2a\x00\x0f\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1e\x00\x14\x00\x15\x00\x15\x00\x15\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +alex_check :: AlexAddr +alex_check = AlexA# "\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x27\x00\x27\x00\x65\x00\x65\x00\x65\x00\x73\x00\x65\x00\x73\x00\x6c\x00\x6e\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x68\x00\x6c\x00\x68\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2b\x00\x6e\x00\x2d\x00\x27\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x20\x00\x20\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\x65\x00\x65\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x20\x00\x20\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x74\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\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\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x09\x00\x0a\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\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x22\x00\x45\x00\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x5f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x3c\x00\x3d\x00\x3e\x00\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\x5c\x00\xff\xff\x5e\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x5f\x00\x7e\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# + +alex_deflt :: AlexAddr +alex_deflt = AlexA# "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1d\x00\x1d\x00\xff\xff\xff\xff\x23\x00\x23\x00\x27\x00\x27\x00\x2b\x00\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x2e\x00\x2f\x00\x2f\x00\x33\x00\x33\x00\x34\x00\x34\x00\x34\x00\x01\x00\x01\x00\x01\x00\x40\x00\x40\x00\x85\x00\x85\x00\x85\x00\xff\xff\xff\xff\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x42\x00\x42\x00\xff\xff\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# + +alex_accept = listArray (0::Int,133) [[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAcc (alex_action_2))],[(AlexAcc (alex_action_2))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_4))],[(AlexAcc (alex_action_5))],[(AlexAcc (alex_action_5))],[(AlexAcc (alex_action_6))],[(AlexAcc (alex_action_7))],[(AlexAcc (alex_action_8))],[(AlexAcc (alex_action_9))],[(AlexAcc (alex_action_9))],[(AlexAcc (alex_action_10))],[(AlexAcc (alex_action_10))],[(AlexAcc (alex_action_11))],[(AlexAcc (alex_action_11))],[(AlexAcc (alex_action_12))],[(AlexAcc (alex_action_13))],[(AlexAcc (alex_action_13))],[(AlexAcc (alex_action_13))],[(AlexAcc (alex_action_14))],[(AlexAcc (alex_action_14))],[(AlexAcc (alex_action_15))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_17))],[(AlexAcc (alex_action_17))],[(AlexAcc (alex_action_18))],[(AlexAcc (alex_action_19))],[(AlexAcc (alex_action_19))],[(AlexAcc (alex_action_21))],[(AlexAcc (alex_action_21))]] +{-# LINE 105 "Language/Eiffel/Parser/Lex.x" #-} + + +tokenMap :: Map.Map Text Token +tokenMap = + Map.fromList + [("true", TokTrue) + ,("false", TokFalse) + ,("void", TokVoid ) + ,("not", TokNot) + ,("old", TokOld) + ,("agent", TokAgent) + ,("alias", TokAlias) + ,("assign", TokAssign) + ,("across", TokAcross) + ,("attached", TokAttached) + ,("inspect", TokInspect) + ,("when", TokWhen) + ,("if", TokIf) + ,("then", TokThen) + ,("else", TokElse) + ,("elseif", TokElseIf) + ,("from", TokFrom) + ,("until", TokUntil) + ,("loop", TokLoop) + ,("variant", TokVariant) + ,("is", TokIs) + ,("do", TokDo) + ,("end", TokEnd) + ,("once", TokOnce) + ,("retry", TokRetry) + ,("rescue", TokRescue) + ,("external", TokExternal) + ,("obsolete", TokObsolete) + ,("built_in", TokBuiltin) + ,("class", TokClass) + ,("inherit", TokInherit) + ,("note", TokNote) + ,("check", TokCheck) + ,("debug", TokDebug) + ,("create", TokCreate) + ,("convert", TokConvert) + ,("result", TokResult) + ,("current", TokCurrent) + ,("precursor", TokPrecursor) + ,("like", TokLike) + ,("detachable", TokDetachable) + ,("separate", TokSeparate) + ,("frozen", TokFrozen) + ,("expanded", TokExpanded) + ,("feature", TokFeature) + ,("local", TokLocal) + ,("deferred", TokDeferred) + ,("attribute", TokAttribute) + ,("export", TokExport) + ,("redefine", TokRedefine) + ,("rename", TokRename) + ,("select", TokSelect) + ,("undefine", TokUndefine) + ,("all", TokAll) + ,("some", TokSome) + ,("ensure", TokEnsure) + ,("require", TokRequire) + ,("invariant", TokInvariant) + ,("as", TokAs) + ] + +opInfoTok op prec assoc = const $ Operator $ BinOpInfo op prec assoc + +operator txt + | txt == "<<" = ArrayStart + | txt == ">>" = ArrayEnd + | otherwise = + case Map.lookup txt operatorMap of + Just opInf -> Operator opInf + _ -> Operator (BinOpInfo (SymbolOp txt) 11 AssocLeft) + +data Assoc = AssocLeft | AssocRight deriving (Eq, Show) +type Prec = Int + +data BinOpInfo = BinOpInfo !BinOp !Prec !Assoc deriving (Eq, Show) + +operatorMap :: Map.Map Text BinOpInfo +operatorMap = + Map.fromList + [ ("^", BinOpInfo Pow 10 AssocRight) + , ("*", BinOpInfo Mul 9 AssocLeft) + , ("/", BinOpInfo Div 9 AssocLeft) + , ("//", BinOpInfo Quot 9 AssocLeft) + , ("\\\\", BinOpInfo Rem 9 AssocLeft) + , ("+", BinOpInfo Add 8 AssocLeft) + , ("-", BinOpInfo Sub 8 AssocLeft) + , ("<=", BinOpInfo (RelOp Lte NoType) 6 AssocLeft) + , ("<", BinOpInfo (RelOp Lt NoType) 6 AssocLeft) + , ("=", BinOpInfo (RelOp Eq NoType) 6 AssocLeft) + , ("~", BinOpInfo (RelOp TildeEq NoType) 6 AssocLeft) + , ("/=", BinOpInfo (RelOp Neq NoType) 6 AssocLeft) + , ("/~", BinOpInfo (RelOp TildeNeq NoType) 6 AssocLeft) + , (">", BinOpInfo (RelOp Gt NoType) 6 AssocLeft) + , (">=", BinOpInfo (RelOp Gte NoType) 6 AssocLeft) + ] + +tokConst :: a -> Text -> a +tokConst = const + +lookupIdentifier :: Text -> Token +lookupIdentifier x = + let x' = Text.toLower x + in case Map.lookup x' tokenMap of + Just t -> t + Nothing -> Identifier x + +data Token + = Identifier Text + | Symbol Char + | String Text + | BlockString Text + | Char Char + | Paren Char + | ArrayStart + | ArrayEnd + | Operator !BinOpInfo + | Float Double + | Integer Integer + | TokTrue + | TokFalse + | TokVoid + | TokNot + | TokOld + | TokAgent + | TokAlias + | TokAssign + | TokAcross + | TokAttached + | TokInspect + | TokWhen + | TokIf + | TokThen + | TokElse + | TokElseIf + | TokFrom + | TokUntil + | TokLoop + | TokVariant + | TokIs + | TokDo + | TokEnd + | TokOnce + | TokRetry + | TokRescue + | TokExternal + | TokObsolete + | TokBuiltin + | TokClass + | TokInherit + | TokNote + | TokCheck + | TokDebug + | TokCreate + | TokConvert + | TokResult + | TokCurrent + | TokPrecursor + | TokLike + | TokDetachable + | TokSeparate + | TokFrozen + | TokExpanded + | TokFeature + | TokLocal + | TokDeferred + | TokAttribute + | TokExport + | TokRedefine + | TokRename + | TokSelect + | TokUndefine + | TokAll + | TokSome + | TokEnsure + | TokEnsureThen + | TokRequire + | TokRequireElse + | TokInvariant + | TokAs + | EOF + | LexError + deriving (Eq, Show) + +bsToText = Text.decodeUtf8 . BS.concat . BL.toChunks + +withPos :: (Text -> Token) -> AlexInput -> Int -> Alex Token +withPos f (_pos, _last, str) i + = return (f $ bsToText $ ByteString.take (fromIntegral i) str) + +bsHexToInteger bs = Integer $ Text.foldl' go 0 (Text.drop 2 bs) + where + go :: Integer -> Char -> Integer + go !acc !c = acc*16 + fromIntegral (hexDigitToInt c) + + hexDigitToInt :: Char -> Int + hexDigitToInt c + | c >= '0' && c <= '9' = ord c - ord '0' + | c >= 'a' && c <= 'f' = ord c - (ord 'a' - 10) + | otherwise = ord c - (ord 'A' - 10) + +type Parser a = Parsec [SpanToken] () a + +data SpanToken = + SpanToken { spanP :: SourcePos + , spanToken :: Token + } + deriving Show + +instance NFData Token where + rnf !t = () + +instance NFData SpanToken where + rnf (SpanToken !pos !tok) = () + +data BlStrNewL = LineStart | MidLine + +alexGetChar input = + case alexGetByte input of + Just (_, input') -> Just (alexInputPrevChar input', input') + Nothing -> Nothing + +blockStringLex :: AlexInput -> Int -> Alex Token +blockStringLex _ _ = do + input <- alexGetInput + go Text.empty LineStart input + where + err input = alexSetInput input >> return LexError + go :: Text -> BlStrNewL -> AlexInput -> Alex Token + go str isNew input = do + case alexGetChar input of + Nothing -> err input + Just (c, input) -> do + case c of + '\r' -> go (Text.cons c str) LineStart input + '\n' -> go (Text.cons c str) LineStart input + ']' -> case alexGetChar input of + Nothing -> err input + Just (c, input) -> do + case c of + '"' -> case isNew of + LineStart -> alexSetInput input >> + return (BlockString $ Text.reverse str) + _ -> go (Text.append "\"]" str) isNew input + _ -> go (Text.cons c str) isNew input + _ -> if isSpace c + then go (Text.cons c str) isNew input + else go (Text.cons c str) MidLine input + +processString :: Text -> Token +processString str = String str -- -- $ either reverse reverse $ foldl go (Right "") str + -- where go (Right acc) '%' = Left acc + -- go (Right acc) c = Right (c:acc) + -- go (Left acc) c = Right (x:acc) + -- where x = case c of + -- 'N' -> '\n' + -- '"' -> '"' + -- '%' -> '%' + -- 'T' -> '\t' + -- 'R' -> '\r' + -- '\n' -> ' ' + -- 'c' -> '^' + -- o -> error ("processString: didn't catch '" ++ + -- [o] ++ + -- "' in " ++ + -- str) + +alexPosnToPos (AlexPn _ line col) = + newPos "FIXME: Lex.hs, no file" + line + col + +grabToken :: (Token -> Maybe a) -> Parser a +grabToken f = Text.Parsec.token show spanP (f . spanToken) + +opSymbol :: Text +opSymbol = "=<>$&|+-/\\~*.#^@?" + +symbolF s (Symbol sym) + | sym == s = Just () + | otherwise = Nothing +symbolF _ _ = Nothing + +identifier = grabToken f + where f (Identifier i) = Just i + f _ = Nothing + +identifierNamed n = grabToken f + where f (Identifier i) + | n == i = Just i + | otherwise = Nothing + f _ = Nothing + +opNamed op = opInfo (SymbolOp op) +opInfo op = grabToken f + where f (Operator (BinOpInfo op' _ _)) + | op == op' = Just () + | otherwise = Nothing + f _ = Nothing + +arrayStart = keyword ArrayStart +arrayEnd = keyword ArrayEnd + +period = opNamed "." + +symbol = grabToken . symbolF + +semicolon = grabToken (symbolF ';') +comma = grabToken (symbolF ',') +colon = grabToken (symbolF ':') + +langle = opInfo (RelOp Lt NoType) +rangle = opInfo (RelOp Gt NoType) +lbrak = keyword (Paren '{') +rbrak = keyword (Paren '}') +lparen = keyword (Paren '(') +rparen = keyword (Paren ')') +lsquare = keyword (Paren '[') +rsquare = keyword (Paren ']') + +braces = between lbrak rbrak +angles = between langle rangle +squares = between lsquare rsquare +parens = between lparen rparen + +attachTokenPos :: Parser a -> Parser (Pos a) +attachTokenPos p = do + tks <- getInput + case tks of + t:_ -> attachPos (spanP t) `fmap` p + _ -> fail "no more input" + +binOpToken :: Int -> Parser (BinOp, Int, Assoc) +binOpToken prec = grabToken f + where f (Operator (BinOpInfo op prec' assoc)) + | prec' >= prec = Just (op, prec', assoc) + | otherwise = Nothing + f _ = Nothing + +-- freeOperator :: Parser String +-- freeOperator = grabToken nonFree "free operator" +-- where +-- nonFree (Operator op) | not (op `elem` predefinedOps) = Just op +-- nonFree _ = Nothing + +-- wordOps = ["and then", "and", "or else", "or", "implies","xor"] + +-- predefinedOps = concat [ ["*","+","-", "^"] +-- , ["<=",">=","=","/=","~","/~"] +-- , ["<<", ">>"] +-- , ["<",">"] +-- , ["\"[","]\""] +-- , [":=","?=","{","}"] +-- , wordOps +-- ] + +type AlexUserState = String + +anyStringTok = stringTok <|> blockStringTok + +blockStringTok = grabToken f + where f (BlockString s) = Just s + f _ = Nothing + +stringTok = grabToken f + where f (String s) = Just s + f _ = Nothing + +charTok = grabToken f + where f (Char c) = Just c + f _ = Nothing + +boolTok = grabToken f + where f TokTrue = Just True + f TokFalse = Just False + f _ = Nothing + +integerTok = grabToken f + where f (Integer i) = Just i + f _ = Nothing + +floatTok = grabToken f + where f (Float d) = Just d + f _ = Nothing + + +keyword t = grabToken f >> return () + where f t' + | t == t' = Just Text.unpack + | otherwise = Nothing + +ignorePendingBytes :: AlexInput -> AlexInput +ignorePendingBytes p = p + +alexInitUserState = "" + +alexEOF :: Alex Token +alexEOF = return EOF + +runTokenizer file str = runAlex str $ + let loop ts = do + tok <- alexMonadScan + (AlexPn _ line col, _lastChar, _string) <- alexGetInput + case tok of + EOF -> return (reverse ts) + LexError -> error ("lexer error: " ++ show (newPos file line col)) + _ -> loop (SpanToken (newPos file line col) tok:ts) + in loop [] + +tokenizer :: String -> Text -> Either String [SpanToken] +tokenizer file txt = runTokenizer file (BL.fromChunks [Text.encodeUtf8 txt]) + +tokenizeFile :: String -> IO (Either String [SpanToken]) +tokenizeFile file = do + s <- BL.readFile file + return $ runTokenizer file s + + +alex_action_2 = withPos (Char . Text.head . Text.tail . Text.init) +alex_action_3 = withPos (opInfoTok AndThen 5 AssocLeft) +alex_action_4 = withPos (opInfoTok And 5 AssocLeft) +alex_action_5 = withPos (opInfoTok OrElse 4 AssocLeft) +alex_action_6 = withPos (opInfoTok Or 4 AssocLeft) +alex_action_7 = withPos (opInfoTok Xor 4 AssocLeft) +alex_action_8 = withPos (opInfoTok Implies 3 AssocLeft) +alex_action_9 = withPos (const TokEnsureThen) +alex_action_10 = withPos (const TokRequireElse) +alex_action_11 = withPos (Float . read . Text.unpack) +alex_action_12 = withPos bsHexToInteger +alex_action_13 = withPos (Integer . read . filter (/= '_') . Text.unpack ) +alex_action_14 = withPos operator +alex_action_15 = withPos (Paren . Text.head) +alex_action_16 = withPos lookupIdentifier +alex_action_17 = withPos (Symbol . Text.head) +alex_action_18 = blockStringLex +alex_action_19 = withPos (processString . Text.tail . Text.init) +alex_action_20 = withPos (tokConst EOF) +alex_action_21 = withPos (tokConst LexError) +{-# LINE 1 "templates/GenericTemplate.hs" #-} +{-# LINE 1 "templates/GenericTemplate.hs" #-} +{-# LINE 1 "" #-} +{-# LINE 1 "" #-} +{-# LINE 1 "templates/GenericTemplate.hs" #-} +-- ----------------------------------------------------------------------------- +-- ALEX TEMPLATE +-- +-- This code is in the PUBLIC DOMAIN; you may copy it freely and use +-- it for any purpose whatsoever. + +-- ----------------------------------------------------------------------------- +-- INTERNALS and main scanner engine + +{-# LINE 37 "templates/GenericTemplate.hs" #-} + +{-# LINE 47 "templates/GenericTemplate.hs" #-} + + +data AlexAddr = AlexA# Addr# + +#if __GLASGOW_HASKELL__ < 503 +uncheckedShiftL# = shiftL# +#endif + +{-# INLINE alexIndexInt16OffAddr #-} +alexIndexInt16OffAddr (AlexA# arr) off = +#ifdef WORDS_BIGENDIAN + narrow16Int# i + where + !i = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low) + !high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#))) + !low = int2Word# (ord# (indexCharOffAddr# arr off')) + !off' = off *# 2# +#else + indexInt16OffAddr# arr off +#endif + + + + + +{-# INLINE alexIndexInt32OffAddr #-} +alexIndexInt32OffAddr (AlexA# arr) off = +#ifdef WORDS_BIGENDIAN + narrow32Int# i + where + !i = word2Int# ((b3 `uncheckedShiftL#` 24#) `or#` + (b2 `uncheckedShiftL#` 16#) `or#` + (b1 `uncheckedShiftL#` 8#) `or#` b0) + !b3 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 3#))) + !b2 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 2#))) + !b1 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#))) + !b0 = int2Word# (ord# (indexCharOffAddr# arr off')) + !off' = off *# 4# +#else + indexInt32OffAddr# arr off +#endif + + + + + +#if __GLASGOW_HASKELL__ < 503 +quickIndex arr i = arr ! i +#else +-- GHC >= 503, unsafeAt is available from Data.Array.Base. +quickIndex = unsafeAt +#endif + + + + +-- ----------------------------------------------------------------------------- +-- Main lexing routines + +data AlexReturn a + = AlexEOF + | AlexError !AlexInput + | AlexSkip !AlexInput !Int + | AlexToken !AlexInput !Int a + +-- alexScan :: AlexInput -> StartCode -> AlexReturn a +alexScan input (I# (sc)) + = alexScanUser undefined input (I# (sc)) + +alexScanUser user input (I# (sc)) + = case alex_scan_tkn user input 0# input sc AlexNone of + (AlexNone, input') -> + case alexGetByte input of + Nothing -> + + + + AlexEOF + Just _ -> + + + + AlexError input' + + (AlexLastSkip input'' len, _) -> + + + + AlexSkip input'' len + + (AlexLastAcc k input''' len, _) -> + + + + AlexToken input''' len k + + +-- Push the input through the DFA, remembering the most recent accepting +-- state it encountered. + +alex_scan_tkn user orig_input len input s last_acc = + input `seq` -- strict in the input + let + new_acc = (check_accs (alex_accept `quickIndex` (I# (s)))) + in + new_acc `seq` + case alexGetByte input of + Nothing -> (new_acc, input) + Just (c, new_input) -> + + + + let + (!(base)) = alexIndexInt32OffAddr alex_base s + (!((I# (ord_c)))) = fromIntegral c + (!(offset)) = (base +# ord_c) + (!(check)) = alexIndexInt16OffAddr alex_check offset + + (!(new_s)) = if (offset >=# 0#) && (check ==# ord_c) + then alexIndexInt16OffAddr alex_table offset + else alexIndexInt16OffAddr alex_deflt s + in + case new_s of + -1# -> (new_acc, input) + -- on an error, we want to keep the input *before* the + -- character that failed, not after. + _ -> alex_scan_tkn user orig_input (if c < 0x80 || c >= 0xC0 then (len +# 1#) else len) + -- note that the length is increased ONLY if this is the 1st byte in a char encoding) + new_input new_s new_acc + + where + check_accs [] = last_acc + check_accs (AlexAcc a : _) = AlexLastAcc a input (I# (len)) + check_accs (AlexAccSkip : _) = AlexLastSkip input (I# (len)) + check_accs (AlexAccPred a predx : rest) + | predx user orig_input (I# (len)) input + = AlexLastAcc a input (I# (len)) + check_accs (AlexAccSkipPred predx : rest) + | predx user orig_input (I# (len)) input + = AlexLastSkip input (I# (len)) + check_accs (_ : rest) = check_accs rest + +data AlexLastAcc a + = AlexNone + | AlexLastAcc a !AlexInput !Int + | AlexLastSkip !AlexInput !Int + +instance Functor AlexLastAcc where + fmap f AlexNone = AlexNone + fmap f (AlexLastAcc x y z) = AlexLastAcc (f x) y z + fmap f (AlexLastSkip x y) = AlexLastSkip x y + +data AlexAcc a user + = AlexAcc a + | AlexAccSkip + | AlexAccPred a (AlexAccPred user) + | AlexAccSkipPred (AlexAccPred user) + +type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool + +-- ----------------------------------------------------------------------------- +-- Predicates on a rule + +alexAndPred p1 p2 user in1 len in2 + = p1 user in1 len in2 && p2 user in1 len in2 + +--alexPrevCharIsPred :: Char -> AlexAccPred _ +alexPrevCharIs c _ input _ _ = c == alexInputPrevChar input + +alexPrevCharMatches f _ input _ _ = f (alexInputPrevChar input) + +--alexPrevCharIsOneOfPred :: Array Char Bool -> AlexAccPred _ +alexPrevCharIsOneOf arr _ input _ _ = arr ! alexInputPrevChar input + +--alexRightContext :: Int -> AlexAccPred _ +alexRightContext (I# (sc)) user _ _ input = + case alex_scan_tkn user input 0# input sc AlexNone of + (AlexNone, _) -> False + _ -> True + -- TODO: there's no need to find the longest + -- match when checking the right context, just + -- the first match will do. + +-- used by wrappers +iUnbox (I# (i)) = i diff --git a/language-eiffel.cabal b/language-eiffel.cabal new file mode 100644 --- /dev/null +++ b/language-eiffel.cabal @@ -0,0 +1,92 @@ +-- language-eiffel.cabal auto-generated by cabal init. For additional +-- options, see +-- http://www.haskell.org/cabal/release/cabal-latest/doc/users-guide/authors.html#pkg-descr. +-- The name of the package. +Name: language-eiffel + +-- The package version. See the Haskell package versioning policy +-- (http://www.haskell.org/haskellwiki/Package_versioning_policy) for +-- standards guiding when and how versions should be incremented. +Version: 0.1 + +-- A short (one-line) description of the package. +Synopsis: Parser and pretty printer for the Eiffel language. + +-- A longer description of the package. +Description: This package provides a base to analyze and transform + the Eiffel language. It is suitable to build parsers. + +-- The license under which the package is released. +License: BSD3 + +-- The file containing the license text. +License-file: LICENSE + +-- The package author(s). +Author: Scott West + +-- An email address to which users can send suggestions, bug reports, +-- and patches. +Maintainer: scott.gregory.west@gmail.com + +Homepage: https://github.com/scottgw/language-eiffel + +-- A copyright notice. +-- Copyright: + +Category: Language + +Build-type: Simple + +-- Extra files to be distributed with the package, such as examples or +-- a README. +-- Extra-source-files: + +-- Constraint on the version of Cabal needed to build this package. +Cabal-version: >=1.6 + + +Library + -- Modules exported by the library. + Exposed-modules: Language.Eiffel.PrettyPrint, + Language.Eiffel.Position, + Language.Eiffel.Syntax + Language.Eiffel.Summary, + Language.Eiffel.Util, + Language.Eiffel.Parser + + -- Packages needed in order to build this package. + Build-depends: array, + base >=4 && < 5, + binary, + bytestring, + deepseq, + derive, + ghc-prim, + hashable, + lens, + pretty, + parsec, + text, + containers, + mtl, + unordered-containers + + -- Modules not exported by this package. + Other-modules: Language.Eiffel.Parser.Class, + Language.Eiffel.Parser.Clause, + Language.Eiffel.Parser.Expr, + Language.Eiffel.Parser.Feature, + Language.Eiffel.Parser.Lex, + Language.Eiffel.Parser.Note, + Language.Eiffel.Parser.Statement, + Language.Eiffel.Parser.Typ + + -- Extra tools (e.g. alex, hsc2hs, ...) needed to build the source. + Build-tools: alex + GHC-Options: -Wall -fno-warn-missing-signatures -fno-warn-unused-do-bind -funbox-strict-fields + +source-repository this + type: git + location: https://github.com/scottgw/language-eiffel + tag: 0.1